@fgv/ts-res 4.5.0-0

package/dist/ts-res.d.ts

@@ -0,0 +1,4282 @@
+import { Brand } from '@fgv/ts-utils';
+import { Collections } from '@fgv/ts-utils';
+import { Converter } from '@fgv/ts-utils';
+import { DetailedResult } from '@fgv/ts-utils';
+import { FileTree } from '@fgv/ts-utils';
+import { ICollectible } from '@fgv/ts-utils';
+import { JsonObject } from '@fgv/ts-json-base';
+import { JsonValue } from '@fgv/ts-json-base';
+import { ObjectConverter } from '@fgv/ts-utils';
+import { Result } from '@fgv/ts-utils';
+import { ResultMap } from '@fgv/ts-utils';
+import { ValidatingCollector } from '@fgv/ts-utils';
+import { ValidatingConvertingCollector } from '@fgv/ts-utils';
+import { ValidatingResultMap } from '@fgv/ts-utils';
+
+/**
+ * An abstract decision represents a class of decisions with candidates
+ * that differ only in value.  It is a {@link Decisions.Decision | IDecision<number>}
+ * in which the `number` values are sequentially assigned indexes.
+ * This allows us to represent each related {@link Decisions.IDecision | decision} as an
+ * {@link Decisions.AbstractDecision | abstract decision} and a matching array containing
+ * the corresponding value for each candidate.  This representation is highly cacheable.
+ * @public
+ */
+declare class AbstractDecision extends Decision<number> {
+    /**
+     * Constructor for an {@link Decisions.AbstractDecision | AbstractDecision} object.
+     * @param params - {@link Decisions.IAbstractDecisionCreateParams | Parameters}
+     * used to create the decision.
+     * @public
+     */
+    protected constructor(params: IAbstractDecisionCreateParams);
+    /**
+     * Creates a new {@link Decisions.AbstractDecision | AbstractDecision} object.
+     * @param params - {@link Decisions.IAbstractDecisionCreateParams | Parameters}
+     * used to create the decision.
+     * @returns `Success` with the new decision if successful, or `Failure` with an
+     * error message if not.
+     * @public
+     */
+    static createAbstractDecision(params: IAbstractDecisionCreateParams): Result<AbstractDecision>;
+}
+
+/**
+ * A `ValidatingCollector` for {@link Decisions.AbstractDecision | AbstractDecisions}.
+ * @public
+ */
+declare class AbstractDecisionCollector extends ValidatingCollector<AbstractDecision> {
+    /**
+     * The {@link Conditions.ReadOnlyConditionSetCollector | ConditionSetCollector} used to create conditions
+     * sets for decisions in this collector.
+     */
+    readonly conditionSets: ReadOnlyConditionSetCollector;
+    /**
+     * The empty decision (no condition sets) for this collector.
+     */
+    get emptyDecision(): AbstractDecision;
+    /**
+     * The default-only decision (one condition set with no conditions) for this collector.
+     */
+    get defaultOnlyDecision(): AbstractDecision;
+    /**
+     * The index for the empty decision.
+     */
+    static readonly EmptyDecisionIndex: DecisionIndex;
+    /**
+     * The index for the default-only decision.
+     */
+    static readonly DefaultOnlyDecisionIndex: DecisionIndex;
+    /**
+     * Creates a new instance of {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+     */
+    protected constructor(params: IAbstractDecisionCollectorCreateParams);
+    /**
+     * Creates a new instance of {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+     * @returns `Success` with the new instance, or `Failure` with an error if the instance could not be created.
+     */
+    static create(params: IAbstractDecisionCollectorCreateParams): Result<AbstractDecisionCollector>;
+    private _toAbstractDecision;
+    private _isConditionSetArray;
+}
+
+/**
+ * Array of all valid condition operators.
+ * @public
+ */
+export declare const allConditionOperators: ConditionOperator[];
+
+/**
+ * Array of all possible {@link ResourceValueMergeMethod | resource merge type} values.
+ * @public
+ */
+export declare const allResourceValueMergeMethods: ResourceValueMergeMethod[];
+
+/**
+ * Converts an array of {@link Helpers.IConditionTokenParts | condition token parts} into an array of
+ * syntactically validated {@link ConditionToken | condition tokens}.
+ * @param parts - the parts to convert
+ * @public
+ */
+declare function buildConditionSetToken(parts: ReadonlyArray<IConditionTokenParts>): Result<ConditionSetToken>;
+
+/**
+ * Converts a {@link Helpers.IConditionTokenParts | the parts that make up a condition token} into
+ * a syntactically validated {@link ConditionToken | condition token}.
+ * @param parts - the parts to convert
+ * @public
+ */
+declare function buildConditionToken({ qualifier, value }: IConditionTokenParts): Result<ConditionToken>;
+
+/**
+ * Simple implementation of {@link Decisions.ICandidate | ICandidate} with
+ * helper methods for sorting and presentation.
+ * @public
+ */
+declare class Candidate<TVALUE extends JsonValue = JsonValue> implements ICandidate<TVALUE> {
+    readonly conditionSet: ConditionSet;
+    readonly value: TVALUE;
+    readonly isPartial: boolean;
+    readonly mergeMethod: ResourceValueMergeMethod;
+    /**
+     * Key of the condition set for this candidate.
+     */
+    get key(): string;
+    /**
+     * Construct a new {@link Decisions.Candidate | Candidate}.
+     * @param params - The {@link Decisions.ICandidate | parameters} to use to create the
+     * new candidate.
+     */
+    protected constructor(params: ICandidate<TVALUE>);
+    /**
+     * Create a new {@link Decisions.Candidate | candidate}.
+     * @param params - The {@link Decisions.ICandidate | parameters} to use to create the
+     * new candidate.
+     * @returns `Success` with the new candidate if successful, or `Failure` if the
+     * candidate could not be created.
+     */
+    static createCandidate<TVALUE extends JsonValue>(params: ICandidate<TVALUE>): Result<Candidate<TVALUE>>;
+    /**
+     * Compare two {@link Decisions.ICandidate | candidates} for sorting purposes.
+     * @param c1 - The first candidate to compare.
+     * @param c2 - The second candidate to compare.
+     * @returns A negative number if c1 should come before c2, a positive number if c1 should
+     * come after c2, or zero if they are equivalent.
+     */
+    static compare(c1: ICandidate, c2: ICandidate): number;
+    /**
+     * Returns a string representation of the {@link Decisions.Candidate | candidate}.
+     * @returns A string representation of this candidate.
+     */
+    toString(): string;
+}
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Json.IChildConditionDecl | child condition declaration}.
+ * @public
+ */
+declare const childConditionDecl: Converter<Json.IChildConditionDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Json.IChildResourceCandidateDecl | child resource candidate declaration}.
+ * @public
+ */
+declare const childResourceCandidateDecl: Converter<Normalized.IChildResourceCandidateDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.IChildResourceDecl | child resource declaration}.
+ * @public
+ */
+declare const childResourceDecl: Converter<Normalized.IChildResourceDecl>;
+
+/**
+ * {@link Import.Importers.IImporter | Importer} implementation which imports
+ * a {@link ResourceJson.ResourceDeclCollection | resource collection} or
+ * {@link ResourceJson.ResourceDeclTree | resource tree} from an importable item.
+ * @public
+ */
+declare class CollectionImporter implements IImporter {
+    /**
+     * {@inheritdoc Import.Importers.IImporter.types}
+     */
+    readonly types: string[];
+    /**
+     * Protected {@link Import.Importers.CollectionImporter | CollectionImporter} constructor for derived classes
+     */
+    protected constructor();
+    /**
+     * Creates a new {@link Import.Importers.CollectionImporter | CollectionImporter} instance.
+     * @returns `Success` with the new {@link Import.Importers.CollectionImporter | CollectionImporter} if successful,
+     * `Failure` o4
+     *
+     * therwise.
+     */
+    static create(): Result<CollectionImporter>;
+    /**
+     * {@inheritdoc Import.Importers.IImporter.import}
+     */
+    import(item: IImportable, manager: ResourceManager): DetailedResult<IImportable[], ImporterResultDetail>;
+    /**
+     * Adds a {@link ResourceJson.Normalized.ILooseResourceDecl | declared resource} to
+     * the supplied {@link Resources.ResourceManager | resource manager}, merging an
+     * optional {@link Import.ImportContext | import context} if provided.
+     * @param manager - The {@link Resources.ResourceManager | resource manager} to which
+     * the resource will be added.
+     * @param resource - The {@link ResourceJson.Normalized.ILooseResourceDecl | resource}
+     * to add.
+     * @param context - Optional {@link Import.ImportContext | import context} to merge
+     * with the resource.
+     * @returns `Success` with the {@link Resources.ResourceBuilder | resource builder}
+     * for the resource if successful, `Failure` with an error message if not.
+     */
+    private _addResource;
+    /**
+     * Adds a {@link ResourceJson.Normalized.ILooseResourceCandidateDecl | declared resource candidate}
+     * to the supplied {@link Resources.ResourceManager | resource manager}, merging an optional
+     * {@link Import.ImportContext | import context} if provided.
+     * @param manager - The {@link Resources.ResourceManager | resource manager} to which the
+     * candidate will be added.
+     * @param candidate - The {@link ResourceJson.Normalized.ILooseResourceCandidateDecl | candidate}
+     * to add.
+     * @param context - Optional {@link Import.ImportContext | import context} to merge with the candidate.
+     * @returns `Success` with the {@link Resources.ResourceCandidate | resource candidate} if successful,
+     * `Failure` with an error message if not.
+     */
+    private _addCandidate;
+}
+
+/**
+ * A {@link Decisions.ConcreteDecision | concrete decision} is a {@link Decisions.IDecision | decision}
+ * implemented as a reference to a common {@link Decisions.AbstractDecision | abstract decision} and a list of
+ * values that correspond to the candidates in the abstract decision.  This allows us to represent a large
+ * number of related decisions with a single abstract decision and a list of values.
+ * @public
+ */
+declare class ConcreteDecision<TVALUE extends JsonValue = JsonValue> implements IDecision<TVALUE> {
+    readonly baseDecision: AbstractDecision;
+    readonly values: TVALUE[];
+    readonly candidates: ReadonlyArray<ICandidate<TVALUE>>;
+    /**
+     * Unique global key for this decision, derived from the condition set and
+     * candidate values.
+     */
+    get key(): DecisionKey;
+    /**
+     * Unique global index for this decision.
+     */
+    get index(): DecisionIndex | undefined;
+    private _collectible;
+    /**
+     * Constructor for a {@link Decisions.ConcreteDecision | ConcreteDecision} object.
+     * @param params - {@link Decisions.IConcreteDecisionConstructorParams | Parameters}
+     * used to create the decision.
+     * @public
+     */
+    protected constructor(params: IConcreteDecisionConstructorParams<TVALUE>);
+    /**
+     * Creates a new {@link Decisions.ConcreteDecision | ConcreteDecision} object.
+     * @param params - {@link Decisions.IConcreteDecisionCreateParams | Parameters}
+     * used to create the decision.
+     * @returns `Success` with the new decision if successful, or `Failure` with an
+     * error message if not.
+     * @public
+     */
+    static create<TVALUE extends JsonValue = JsonValue>(params: IConcreteDecisionCreateParams<TVALUE>): Result<ConcreteDecision<TVALUE>>;
+    /**
+     * Sets the index for this decision.  Once set, index is immutable.
+     * @param index - The index to set.
+     * @returns `Success` with the new index if successful, or `Failure` with an error message if not.
+     */
+    setIndex(index: number): Result<DecisionIndex>;
+}
+
+/**
+ * Represents a single condition applied to some resource instance.
+ * @public
+ */
+declare class Condition implements IValidatedConditionDecl {
+    /**
+     * The {@link Qualifiers.Qualifier | qualifier} used in this condition.
+     */
+    readonly qualifier: Qualifier;
+    /**
+     * The value to be matched in this condition.
+     */
+    readonly value: QualifierConditionValue;
+    /**
+     * The {@link ConditionOperator | operator} used when matching context value to condition value.
+     */
+    readonly operator: ConditionOperator;
+    /**
+     * The {@link ConditionPriority | relative priority} of this condition.
+     */
+    readonly priority: ConditionPriority;
+    /**
+     * The {@link QualifierMatchScore | score} to be used when this condition is the default.
+     */
+    readonly scoreAsDefault?: QualifierMatchScore;
+    protected _collectible: Collections.Collectible<ConditionKey, ConditionIndex>;
+    /**
+     * Constructs a new {@link Conditions.Condition | Condition} object.
+     * @param qualifier - The {@link Qualifiers.Qualifier | qualifier} used in this condition.
+     * @param value - The value to be matched in this condition.
+     * @param operator - The {@link ConditionOperator | operator} used when matching context value to condition value.
+     * @param priority - The {@link ConditionPriority | relative priority} of this condition.
+     * @public
+     */
+    protected constructor({ qualifier, value, operator, priority, scoreAsDefault, index }: IValidatedConditionDecl);
+    get key(): ConditionKey;
+    get index(): ConditionIndex | undefined;
+    setIndex(index: ConditionIndex): Result<ConditionIndex>;
+    /**
+     * Creates a new {@link Conditions.Condition | Condition} object from the supplied
+     * {@link Conditions.IValidatedConditionDecl | validated condition declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+     * describing the condition to create.
+     * @returns `Success` with the new {@link Conditions.Condition | Condition} if successful,
+     * `Failure` otherwise.
+     * @public
+     */
+    static create(decl: IValidatedConditionDecl): Result<Condition>;
+    /**
+     * Compares two conditions for sorting purposes.
+     * @param c1 - The first {@link Conditions.Condition | condition} to compare.
+     * @param c2 - The second {@link Conditions.Condition | condition} to compare.
+     * @returns A negative number if c1 should come before c2, a positive number
+     * if c2 should come before c1, or zero if they are equivalent.
+     * @public
+     */
+    static compare(c1: Condition, c2: Condition): number;
+    /**
+     * Gets a {@link ConditionToken | condition token} for this condition, if possible.
+     * It is not possible to get a token for a condition with an operator other than `matches`,
+     * with other-than-default priority, or with a name or value that contains other than alphanumeric
+     * characters, underscore or non-leading hyphen.
+     * @param terse - if `true` and if the qualifier token is optional, the token will be omitted
+     * from the generated {@link ConditionToken | condition token}.
+     * @returns
+     */
+    toToken(terse?: boolean): Result<ConditionToken>;
+    /**
+     * Gets the {@link ConditionKey | key} for this condition.
+     * @returns -
+     */
+    toKey(): ConditionKey;
+    /**
+     * Get a human-readable string representation of the condition.
+     * @returns A string representation of the condition.
+     * @public
+     */
+    toString(): string;
+    /**
+     * Gets the {@link ConditionKey | condition key} for a supplied {@link Conditions.IValidatedConditionDecl | condition declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionDecl | condition declaration} for which to get the key.
+     * @returns `Success` with the condition key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyForDecl(decl: IValidatedConditionDecl): Result<ConditionKey>;
+}
+
+/**
+ * A `ValidatingCollector` for {@link Conditions.Condition | Conditions},
+ * which collects conditions supplied as either {@link Conditions.Condition | Condition} or
+ * {@link Conditions.IConditionDecl | IConditionDecl}.
+ * @public
+ */
+declare class ConditionCollector extends ValidatingCollector<Condition> {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | ReadOnlyQualifierCollector} used to create conditions
+     * in this collector.
+     * @public
+     */
+    qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * Constructor for a {@link Conditions.ConditionCollector | ConditionCollector} object.
+     * @param params - Required {@link Conditions.IConditionCollectorCreateParams | parameters} for
+     * creating the collector.
+     */
+    protected constructor(params: IConditionCollectorCreateParams);
+    /**
+     * Creates a new {@link Conditions.ConditionCollector | ConditionCollector} object.
+     * @param params - Required {@link Conditions.IConditionCollectorCreateParams | parameters} for
+     * creating the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` with
+     * an error message if not.
+     */
+    static create(params: IConditionCollectorCreateParams): Result<ConditionCollector>;
+    private _toCondition;
+}
+
+/**
+ * Converter for a {@link Conditions.IConditionDecl | condition declaration}.
+ * @public
+ */
+declare const conditionDecl: ObjectConverter<IConditionDecl, unknown>;
+
+/**
+ * Branded number representing a validated condition index.
+ * @public
+ */
+export declare type ConditionIndex = Brand<number, 'ConditionIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionIndex | ConditionIndex}.
+ * @public
+ */
+declare const conditionIndex: Converter<ConditionIndex, unknown>;
+
+/**
+ * A branded string representing a validated condition key.  A condition key is a
+ * string value which fully describes the condition apart from index.  The condition
+ * key can be used to quickly determine if two conditions are identical apart from
+ * index, or for inspection.
+ * @public
+ */
+export declare type ConditionKey = Brand<string, 'ConditionKey'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionKey | ConditionKey}.
+ * @public
+ */
+declare const conditionKey: Converter<ConditionKey, unknown>;
+
+/**
+ * The format of a {@link ConditionKey | condition key} is:
+ * <qualifierName>-[<value>][\@<priority>](<scoreAsDefault>) where operator is `matches`, or
+ * <qualifierName>-<operator>-[<value>][\@<priority>](<scoreAsDefault>)
+ * @internal
+ */
+declare const conditionKey_2: RegExp;
+
+/**
+ * Condition operators for use in conditions.
+ * @public
+ */
+export declare type ConditionOperator = 'always' | 'never' | 'matches';
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionOperator | ConditionOperator}.
+ * @public
+ */
+declare const conditionOperator: Converter<ConditionOperator, ConditionOperator[]>;
+
+/**
+ * Branded number representing a validated condition priority.
+ * @public
+ */
+export declare type ConditionPriority = Brand<number, 'ConditionPriority'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionPriority | ConditionPriority}.
+ * @public
+ */
+declare const conditionPriority: Converter<ConditionPriority, unknown>;
+
+declare namespace Conditions {
+    export {
+        Convert_2 as Convert,
+        Condition,
+        IConditionCollectorCreateParams,
+        ConditionCollector,
+        ReadOnlyConditionCollector,
+        IConditionDecl,
+        IValidatedConditionDecl,
+        ConditionSet,
+        IConditionSetCollectorCreateParams,
+        ConditionSetCollector,
+        ReadOnlyConditionSetCollector,
+        IConditionSetDecl,
+        IValidatedConditionSetDecl,
+        ConditionTokens
+    }
+}
+export { Conditions }
+
+/**
+ * Represents a set of {@link Conditions.Condition | conditions} that must all be met in some runtime
+ * context for a resource instance to be valid.
+ * @public
+ */
+declare class ConditionSet implements IValidatedConditionSetDecl {
+    protected readonly _collectible: Collections.Collectible<ConditionSetKey, ConditionSetIndex>;
+    /**
+     * The {@link Conditions.Condition | conditions} that make up this condition
+     * set.
+     * @public
+     */
+    readonly conditions: ReadonlyArray<Condition>;
+    /**
+     * The key for this condition set.
+     */
+    get key(): ConditionSetKey;
+    /**
+     * The number of conditions in this condition set.
+     */
+    get size(): number;
+    /**
+     * The index for this condition set.
+     */
+    get index(): ConditionSetIndex | undefined;
+    /**
+     * The key for an unconditional condition set.
+     */
+    static UnconditionalKey: ConditionSetKey;
+    /**
+     * Constructor for a {@link Conditions.ConditionSet | ConditionSet} object.
+     * @param params - {@link Conditions.IValidatedConditionSetDecl | Validated declaration}
+     * used to create the condition set.
+     */
+    protected constructor(params: IValidatedConditionSetDecl);
+    /**
+     * Creates a new {@link Conditions.ConditionSet | ConditionSet} object.
+     * @param params - {@link Conditions.IValidatedConditionSetDecl | Validated declaration}
+     * used to create the condition set.
+     * @returns `Success` with the new {@link Conditions.ConditionSet | ConditionSet} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IValidatedConditionSetDecl): Result<ConditionSet>;
+    /**
+     * Compares two {@link Conditions.ConditionSet | ConditionSets} for sorting purposes.
+     * @param cs1 - The first {@link Conditions.ConditionSet | ConditionSet} to compare.
+     * @param cs2 - The second {@link Conditions.ConditionSet | ConditionSet} to compare.
+     * @returns A negative number if `cs1` should come before `cs2`, a positive
+     * number if `cs1` should come after `cs2`, or zero if they are equivalent.
+     * @public
+     */
+    static compare(cs1: ConditionSet, cs2: ConditionSet): number;
+    /**
+     * Sets the global index for this condition set.  Once set, the index cannot be changed.
+     * @param index - The index to set for this condition set.
+     * @returns `Success` with the index if successful, `Failure` otherwise.
+     */
+    setIndex(index: number): Result<ConditionSetIndex>;
+    /**
+     * Gets the {@link ConditionSetKey | key} for a supplied {@link Conditions.IValidatedConditionSetDecl | condition set declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionSetDecl | condition set declaration} for which to get the key.
+     * @returns `Success` with the condition set key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyForDecl(decl: IValidatedConditionSetDecl): Result<ConditionSetKey>;
+    /**
+     * Gets a {@link ConditionSetToken | condition set token} for this condition set,
+     * if possible.
+     * @param terse - If true, the token will be terse, omitting qualifier names where
+     * possible.
+     * @returns `Success` with the {@link ConditionSetToken | condition set token} if successful,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    toToken(terse?: boolean): Result<string>;
+    /**
+     * Gets the {@link ConditionSetKey | key} for this condition set.
+     * @returns The key for this condition set.
+     */
+    toKey(): ConditionSetKey;
+    /**
+     * Gets a hash of this condition set.
+     * @returns A hash of this condition
+     * set key.
+     * @public
+     */
+    toHash(): string;
+    /**
+     * Gets a human-readable string representation of this condition set.
+     * @returns A string representation of this condition set.
+     */
+    toString(): string;
+}
+
+/**
+ * A `ValidatingCollector` for {@link Conditions.ConditionSet | ConditionSets},
+ * which collects condition sets supplied as {@link Conditions.ConditionSet | ConditionSet} or
+ * as {@link Conditions.IConditionSetDecl | IConditionSetDecl} via the methods on the
+ * `validating` property.
+ * @public
+ */
+declare class ConditionSetCollector extends ValidatingCollector<ConditionSet> {
+    /**
+     * Gets the {@link Conditions.ConditionCollector | ConditionCollector} used to create conditions
+     * for conditions in this collector.
+     */
+    conditions: ConditionCollector;
+    /**
+     * Gets the {@link Conditions.ConditionSet | ConditionSet} at the unconditional
+     * condition set index.
+     */
+    get unconditionalConditionSet(): ConditionSet;
+    /**
+     * The index of the unconditional condition set.
+     */
+    static UnconditionalIndex: ConditionSetIndex;
+    /**
+     * Creates a new {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+     * @param params - {@link Conditions.IConditionSetCollectorCreateParams | Parameters} used to create
+     * the collector.
+     */
+    protected constructor(params: IConditionSetCollectorCreateParams);
+    /**
+     * Creates a new {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+     * @param params - {@link Conditions.IConditionSetCollectorCreateParams | Parameters} used to create
+     * the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` with an error message
+     * if not.
+     */
+    static create(params: IConditionSetCollectorCreateParams): Result<ConditionSetCollector>;
+    private _toConditionSet;
+}
+
+/**
+ * Non-validated declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare type ConditionSetDecl = ConditionSetDeclAsArray | ConditionSetDeclAsRecord;
+
+/**
+ * Converter which converts to a {@link Conditions.IConditionSetDecl | condition set declaration}.
+ * @public
+ */
+declare const conditionSetDecl: ObjectConverter<IConditionSetDecl, unknown>;
+
+/**
+ * Normalized non-validated declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare type ConditionSetDecl_2 = ReadonlyArray<ILooseConditionDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.ConditionSetDecl | condition set declaration}.
+ * @public
+ */
+declare const conditionSetDecl_2: Converter<Normalized.ConditionSetDecl>;
+
+/**
+ * Non-validated declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare type ConditionSetDeclAsArray = ReadonlyArray<ILooseConditionDecl>;
+
+/**
+ * Non-validated declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare type ConditionSetDeclAsRecord = Record<string, string | IChildConditionDecl>;
+
+/**
+ * Branded string representing a hash value for a condition set. The hash value
+ * is an 8-character string derived from the crc32 hash of the condition set key
+ * and is used to quickly and compactly identify a condition set or compare for
+ * equality.
+ * @public
+ */
+export declare type ConditionSetHash = Brand<string, 'ConditionSetHash'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionSetHash | ConditionSetHash}.
+ * @public
+ */
+declare const conditionSetHash: Converter<ConditionSetHash, unknown>;
+
+/**
+ * @internal
+ */
+declare const conditionSetHash_2: RegExp;
+
+/**
+ * Branded number representing a validated condition set index.
+ * @public
+ */
+export declare type ConditionSetIndex = Brand<number, 'ConditionSetIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionSetIndex | ConditionSetIndex}.
+ * @public
+ */
+declare const conditionSetIndex: Converter<ConditionSetIndex, unknown>;
+
+/**
+ * Branded string representing a validated condition set key. A condition set key
+ * is a string value which fully describes the condition set apart from index. The
+ * condition set key can be used to quickly determine if two condition sets are
+ * identical apart from index, or for inspection.
+ * @public
+ */
+export declare type ConditionSetKey = Brand<string, 'ConditionSetKey'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionSetKey | ConditionSetKey}.
+ * @public
+ */
+declare const conditionSetKey: Converter<ConditionSetKey, unknown>;
+
+/**
+ * A string representing a validated condition set token.  Condition set tokens are
+ * typically extracted from the name of some resource (e.g. file or folder) being
+ * imported.  A condition set token is a comma-separated list of one or more
+ * {@link ConditionToken | condition tokens}, where a condition token has either
+ * the form `<qualifierName>=<value>` or `<value>`.
+ * @public
+ */
+export declare type ConditionSetToken = Brand<string, 'ConditionSetToken'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionSetToken | ConditionSetToken}.
+ * @public
+ */
+declare const conditionSetToken: Converter<ConditionSetToken, unknown>;
+
+/**
+ * A string representing a validated condition token.  Condition tokens are
+ * typically extracted from the name of some resource (e.g. file or folder)
+ * being imported.   A condition token has the form `<qualifierName>=<value>`
+ * or `<value>`.
+ * @public
+ */
+export declare type ConditionToken = Brand<string, 'ConditionToken'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ConditionToken | ConditionToken}.
+ * @public
+ */
+declare const conditionToken: Converter<ConditionToken, unknown>;
+
+/**
+ * A {@link ConditionToken | condition token} is a comma-separated list of one or more
+ * condition specifiers, where a condition specifier has either the form
+ * `<qualifierName>=<value>` or `<value>`.
+ * @internal
+ */
+declare const conditionToken_2: RegExp;
+
+/**
+ * Helper class to parse and validate condition tokens.
+ * @public
+ */
+declare class ConditionTokens {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to validate
+     * qualifier names and values.
+     */
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * Constructs a new {@link Conditions.ConditionTokens | ConditionTokens } instance.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     */
+    constructor(qualifiers: IReadOnlyQualifierCollector);
+    /**i
+     * Parses a {@link ConditionToken | condition token} string and validates the parts
+     * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseConditionToken(token: string): Result<IValidatedConditionDecl>;
+    /**
+     * Parses a {@link ConditionSetToken | condition set token} string and validates the parts
+     * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseConditionSetToken(token: string): Result<IValidatedConditionDecl[]>;
+    /**
+     * Validates the {@link Helpers.IConditionTokenParts | parts} of a {@link ConditionToken | condition token}.
+     * @param parts - the parts to validate
+     * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.
+     */
+    validateConditionTokenParts(parts: Helpers.IConditionTokenParts): Result<IValidatedConditionDecl>;
+    /**
+     * Given a value, finds a single token-optional qualifier that matches the value.
+     * Fails if no qualifiers match, or if more than one qualifier matches.
+     * @param value - the value to match.
+     * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+     */
+    findQualifierForValue(value: string): Result<Qualifier>;
+    /**
+     * Parses a {@link ConditionToken | condition token} and validates it against the qualifiers
+     * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param token - the token string to parse.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static parseConditionToken(token: string, qualifiers: IReadOnlyQualifierCollector): Result<IValidatedConditionDecl>;
+    /**
+     * Parses a {@link ConditionSetToken | condition set token} and validates it against the qualifiers
+     * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param token - the token string to parse.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     * @returns `Success` with an array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+     * if successful, `Failure` with an error message if not
+     */
+    static parseConditionSetToken(token: string, qualifiers: IReadOnlyQualifierCollector): Result<IValidatedConditionDecl[]>;
+    /**
+     * Validates the parts of a condition token against the qualifiers present in the supplied
+     * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param parts - the {@link Helpers.IConditionTokenParts | condition token parts} to validate.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to
+     * validate qualifier names and values.
+     * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static validateConditionTokenParts(parts: Helpers.IConditionTokenParts, qualifiers: IReadOnlyQualifierCollector): Result<IValidatedConditionDecl>;
+    /**
+     * Given a value and a set of qualifiers, finds a single token-optional qualifier that matches the value.
+     * Fails if no qualifiers match, or if more than one qualifier matches.
+     * @param value - the value to match.
+     * @param qualifiers - the qualifiers to match against.
+     * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+     */
+    static findQualifierForValue(value: string, qualifiers: IReadOnlyQualifierCollector): Result<Qualifier>;
+}
+
+declare namespace Convert {
+    export {
+        qualifierName,
+        qualifierIndex,
+        qualifierTypeName,
+        qualifierTypeIndex,
+        qualifierMatchScore,
+        conditionPriority,
+        conditionOperator,
+        conditionIndex,
+        conditionKey,
+        conditionToken,
+        conditionSetIndex,
+        conditionSetKey,
+        conditionSetToken,
+        conditionSetHash,
+        decisionIndex,
+        decisionKey,
+        resourceId,
+        resourceName,
+        resourceIndex,
+        resourceTypeName,
+        resourceTypeIndex,
+        resourceValueMergeMethod
+    }
+}
+export { Convert }
+
+declare namespace Convert_2 {
+    export {
+        conditionDecl,
+        IConditionDeclConvertContext,
+        validatedConditionDecl,
+        conditionSetDecl,
+        IConditionSetDeclConvertContext,
+        validatedConditionSetDecl
+    }
+}
+
+declare namespace Convert_3 {
+    export {
+        looseConditionDecl,
+        childConditionDecl,
+        conditionSetDecl_2 as conditionSetDecl,
+        looseResourceCandidateDecl,
+        childResourceCandidateDecl,
+        looseResourceDecl,
+        childResourceDecl,
+        resourceTreeChildNodeDecl,
+        resourceTreeRootDecl,
+        resourceCollectionDecl
+    }
+}
+
+declare namespace Convert_4 {
+    export {
+        IQualifierTypeConvertContext,
+        qualifierType
+    }
+}
+
+declare namespace Convert_5 {
+    export {
+        qualifierDecl,
+        IQualifierDeclConvertContext,
+        validatedQualifierDecl,
+        IQualifierConvertContext,
+        qualifier
+    }
+}
+
+/**
+ * Simple collectible implementation of {@link Decisions.IDecision | IDecision}.
+ * @public
+ */
+declare class Decision<TVALUE extends JsonValue = JsonValue> implements IDecision<TVALUE> {
+    /**
+     * The sorted {@link Conditions.ConditionSet  | ConditionSets} that make up this decision.
+     * @public
+     */
+    readonly candidates: ReadonlyArray<Candidate<TVALUE>>;
+    /**
+     * Unique global key for this decision, derived from the contents
+     * of the decision.
+     */
+    get key(): DecisionKey;
+    /**
+     * Unique global index for this decision.
+     */
+    get index(): DecisionIndex | undefined;
+    /**
+     * Key for the empty decision (no condition sets).
+     */
+    static readonly EmptyDecisionKey: DecisionKey;
+    /**
+     * Key for the default-only decision (single condition set with no conditions).
+     */
+    static readonly DefaultOnlyDecisionKey: DecisionKey;
+    private _collectible;
+    /**
+     * Constructor for a {@link Decisions.Decision | Decision} object.
+     * @param params - {@link Decisions.IDecisionConstructorParams | Parameters} used to create the decision.
+     * @public
+     */
+    protected constructor(params: IDecisionConstructorParams<TVALUE>);
+    /**
+     * Creates a new {@link Decisions.Decision | Decision} object.
+     * @param params - {@link Decisions.IDecisionCreateParams | Parameters} used to create the decision.
+     * @returns `Success` with the new decision if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    static createDecision(params: IDecisionCreateParams): Result<Decision>;
+    /**
+     * Sets the index for this decision.  Once set, index is immutable.
+     * @param index - The index to set.
+     * @returns `Success` with the new index if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    setIndex(index: number): Result<DecisionIndex>;
+    /**
+     * Helper function to return a stable key for a the condition sets that
+     * make up a {@link Decisions.Decision | decision}.  The abstract
+     * key is a `+`-separated list of the hashes of the sorted condition sets
+     * that make up the decision.
+     * @param conditionSets - The condition sets to use to create the key.
+     * @returns A key derived from the condition set hashes.
+     * @public
+     */
+    static getAbstractKey(conditionSets: ReadonlyArray<ConditionSet>): DecisionKey;
+    /**
+     * Helper function to return a stable key for a set of condition sets.
+     * @param conditionSets - The condition sets to use to create the key.
+     * @returns A key derived from the condition set hashes.
+     * @public
+     */
+    static getKey<TVALUE extends JsonValue = JsonValue>(candidates: ReadonlyArray<ICandidate<TVALUE>>): DecisionKey;
+}
+
+/**
+ * Branded number representing a validated decision index.
+ * @public
+ */
+export declare type DecisionIndex = Brand<number, 'DecisionIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link DecisionIndex | DecisionIndex}.
+ * @public
+ */
+declare const decisionIndex: Converter<DecisionIndex, unknown>;
+
+/**
+ * Branded string representing a validated decision key. A decision key is a string
+ * value which fully describes the decision apart from index. The decision key can
+ * be used to quickly determine if two decisions are identical apart from index.
+ * @public
+ */
+export declare type DecisionKey = Brand<string, 'DecisionKey'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link DecisionKey | DecisionKey}.
+ * @public
+ */
+declare const decisionKey: Converter<DecisionKey, unknown>;
+
+/**
+ * @internal
+ */
+declare const decisionKey_2: RegExp;
+
+declare namespace Decisions {
+    export {
+        IDecision,
+        ICandidate,
+        Candidate,
+        IDecisionCreateParams,
+        IDecisionConstructorParams,
+        Decision,
+        IAbstractDecisionCreateParams,
+        AbstractDecision,
+        IAbstractDecisionCollectorCreateParams,
+        AbstractDecisionCollector,
+        ReadOnlyAbstractDecisionCollector,
+        IConcreteDecisionCreateParams,
+        IConcreteDecisionConstructorParams,
+        ConcreteDecision
+    }
+}
+export { Decisions }
+
+/**
+ * Class describing some file system item to be imported.
+ * @public
+ */
+declare class FsItem implements IFsItemProps {
+    /**
+     * {@inheritDoc Import.IFsItemProps.baseName}
+     */
+    readonly baseName: string;
+    /**
+     * {@inheritDoc Import.IFsItemProps.conditions}
+     */
+    readonly conditions: Conditions.IValidatedConditionDecl[];
+    /**
+     * {@inheritDoc Import.IFsItemProps.item}
+     */
+    readonly item: FileTree.FileTreeItem;
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} to use for this item.
+     */
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * Protected constructor creates a new {@link Import.FsItem | FsItem}.
+     * @param props - The {@link Import.IFsItemProps | file system item properties} to use for this item.
+     * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+     * embedded condition set tokens.
+     * @param tree - file tree implementation to use for this item.
+     * @returns `Success` containing the new {@link Import.FsItem | FsItem} if successful, or a `Failure`
+     * containing an error message if not.
+     */
+    protected constructor(props: IFsItemProps, qualifiers: IReadOnlyQualifierCollector);
+    /**
+     * Creates a new {@link Import.FsItem | FsItem} from a `FileTreeItem`.
+     * @param item - The `FileTreeItem` to import.
+     * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+     * embedded condition set tokens.
+     * @returns `Success` containing the new {@link Import.FsItem | FsItem} if successful, or a `Failure`
+     * containing an error message if not.  Note that the result detail `skipped` indicates that the item
+     * was not created because it is not relevant - this is a soft error that should be silently ignored.
+     */
+    static createForItem(item: FileTree.FileTreeItem, qualifiers: IReadOnlyQualifierCollector): DetailedResult<FsItem, FsItemResultDetail>;
+    /**
+     * Creates a new {@link Import.FsItem | FsItem} from a file system path.
+     * @param importPath - The path to the file system item to import.
+     * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+     * embedded condition set tokens.
+     * @param fs - An optional {@link Import.IImporterFilesystem | file system implementation} to use for this item.
+     * @returns `Success` containing the new {@link Import.FsItem | FsItem} if an item is created
+     * successfully, or a `Failure` containing an error message if it is not.  Note that the result detail
+     * `skipped` indicates that the item was not created because it is not relevant - this is a soft error
+     * that should be silently ignored.
+     */
+    static createForPath(importPath: string, qualifiers: IReadOnlyQualifierCollector, tree?: FileTree.FileTree): DetailedResult<FsItem, FsItemResultDetail>;
+    /**
+     * Tries to parse a base name into a base name and a set of conditions.
+     * @param baseName - The base name to parse.
+     * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used to parse
+     * embedded condition set tokens.
+     * @returns `Success` containing the parsed base name and conditions on success, or `Failure` containing
+     * an error message if it is not.
+     */
+    static tryParseBaseName(baseName: string, qualifiers: IReadOnlyQualifierCollector): Result<Omit<IFsItemProps, 'item'>>;
+    /**
+     * Gets the context for this file system item.
+     * @returns `Success` containing the {@link Import.ImportContext | import context} for this item
+     * if successful, or a `Failure` containing an error message if an error occurs.
+     */
+    getContext(): Result<ImportContext>;
+}
+
+/**
+ * {@link Import.Importers.IImporter | Importer} implementation which imports resources from a `FileTree`.
+ * @public
+ */
+declare class FsItemImporter implements IImporter {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use for this importer.
+     */
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * The types of {@link Import.IImportable | importables} that this importer can handle.
+     */
+    readonly types: ReadonlyArray<string>;
+    /**
+     * Protected constructor for the {@link Import.Importers.FsItemImporter | FsItemImporter}.
+     * @param params - Parameters for creating the {@link Import.Importers.FsItemImporter | FsItemImporter}.
+     */
+    protected constructor(params: IFsItemImporterCreateParams);
+    /**
+     * Creates a new {@link Import.Importers.FsItemImporter | FsItemImporter}.
+     * @param params - Parameters for creating the {@link Import.Importers.FsItemImporter | FsItemImporter}.
+     * @returns `Success` with the new `FsItemImporter` if successful, `Failure` with an error message if not.
+     */
+    static create(params: IFsItemImporterCreateParams): Result<FsItemImporter>;
+    /**
+     * {@inheritdoc Import.Importers.IImporter.import}
+     */
+    import(item: IImportable, __manager: ResourceManager): DetailedResult<IImportable[], ImporterResultDetail>;
+    /**
+     * Gets an {@link Import.FsItem | FsItem} from an {@link Import.IImportable | importable}.
+     * @param item - The importable to convert.
+     * @returns `Success` containing the `FsItem` if successful, `Failure` with an error message if not.
+     */
+    protected _getFileTreeItemFromImportable(item: IImportable): DetailedResult<FsItem, FsItemResultDetail>;
+}
+
+/**
+ * Result details for {@link Import.FsItem | FsItem} operations.
+ * @public
+ */
+declare type FsItemResultDetail = 'failed' | 'skipped' | 'succeeded';
+
+declare namespace Helpers {
+    export {
+        buildConditionToken,
+        buildConditionSetToken,
+        parseConditionTokenParts,
+        parseConditionSetTokenParts,
+        IConditionTokenParts,
+        splitResourceId,
+        joinResourceIds,
+        joinOptionalResourceIds
+    }
+}
+export { Helpers }
+
+declare namespace Helpers_2 {
+    export {
+        mergeLooseCandidate,
+        mergeChildCandidate,
+        mergeLooseResource,
+        mergeChildResource
+    }
+}
+
+/**
+ * Parameters for creating a {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+ * @public
+ */
+declare interface IAbstractDecisionCollectorCreateParams {
+    /**
+     * {@link Conditions.ReadOnlyConditionSetCollector | ConditionSetCollector} used to create conditions
+     * sets for decisions in this collector.
+     */
+    conditionSets: ReadOnlyConditionSetCollector;
+}
+
+/**
+ * Parameters to create an {@link Decisions.AbstractDecision | AbstractDecision}.
+ * @public
+ */
+declare interface IAbstractDecisionCreateParams {
+    conditionSets: ConditionSet[];
+    index?: number;
+}
+
+/**
+ * A {@link Decisions.ICandidate | resource candidate} represents a single
+ * possible value for some resource, with the conditions under which it is valid.
+ * @public
+ */
+declare interface ICandidate<TVALUE extends JsonValue = JsonValue> {
+    readonly conditionSet: ConditionSet;
+    readonly value: TVALUE;
+    readonly isPartial?: boolean;
+    readonly mergeMethod?: ResourceValueMergeMethod;
+}
+
+/**
+ * Non-validated child declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare interface IChildConditionDecl {
+    /**
+     * The value to be compared.
+     */
+    value: string;
+    /**
+     * The operator to be used in the comparison.
+     * Default is 'matches'.
+     */
+    operator?: ConditionOperator;
+    /**
+     * The priority of the condition. Default is the default priority for the qualifier.
+     */
+    priority?: number;
+    /**
+     * The score to be used if the condition is used as a default.
+     */
+    scoreAsDefault?: number;
+}
+
+/**
+ * Non-validated child declaration of a {@link Resources.ResourceCandidate | resource candidate}.
+ * @public
+ */
+declare interface IChildResourceCandidateDecl {
+    /**
+     * The JSON value of the resource.
+     */
+    readonly json: JsonObject;
+    /**
+     * The conditions that must be met for the resource to be selected.
+     */
+    readonly conditions?: ConditionSetDecl;
+    /**
+     * If true, the resource is only a partial representation of the full resource.
+     */
+    readonly isPartial?: boolean;
+    /**
+     * The merge method to be used when merging the resource into the existing resource.
+     * default is 'augment'.
+     */
+    readonly mergeMethod?: ResourceValueMergeMethod;
+}
+
+/**
+ * Normalized non-validated child declaration of a {@link Resources.ResourceCandidate | resource candidate}.
+ * @public
+ */
+declare interface IChildResourceCandidateDecl_2 {
+    /**
+     * The JSON value of the resource.
+     */
+    readonly json: JsonObject;
+    /**
+     * The conditions that must be met for the resource to be selected.
+     */
+    readonly conditions?: ConditionSetDecl_2;
+    /**
+     * If true, the resource is only a partial representation of the full resource.
+     */
+    readonly isPartial?: boolean;
+    /**
+     * The merge method to be used when merging the resource into the existing resource.
+     * default is 'augment'.
+     */
+    readonly mergeMethod?: ResourceValueMergeMethod;
+}
+
+/**
+ * Non-validated child declaration of a {@link Resources.Resource | resource}.
+ * @public
+ */
+declare interface IChildResourceDecl {
+    /**
+     * The name of the type of this resource.
+     */
+    readonly resourceTypeName: string;
+    /**
+     * Possible candidates for this value.
+     */
+    readonly candidates?: ReadonlyArray<IChildResourceCandidateDecl>;
+}
+
+/**
+ * Normalized non-validated child declaration of a {@link Resources.Resource | resource}.
+ * @public
+ */
+declare interface IChildResourceDecl_2 {
+    /**
+     * The name of the type of this resource.
+     */
+    readonly resourceTypeName: string;
+    /**
+     * Possible candidates for this value.
+     */
+    readonly candidates?: ReadonlyArray<IChildResourceCandidateDecl_2>;
+}
+
+/**
+ * Protected constructor parameters for {@link Decisions.ConcreteDecision | ConcreteDecision},
+ * used to create a new concrete decision from an existing {@link Decisions.AbstractDecision | AbstractDecision}
+ * and a list of values.
+ * @public
+ */
+declare interface IConcreteDecisionConstructorParams<TVALUE extends JsonValue = JsonValue> {
+    baseDecision: AbstractDecision;
+    values: TVALUE[];
+    index?: DecisionIndex;
+}
+
+/**
+ * Parameters used to create a new {@link Decisions.ConcreteDecision | ConcreteDecision},
+ * given an {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector} and a
+ * list of {@link Decisions.ICandidate | candidates}.
+ * @public
+ */
+declare interface IConcreteDecisionCreateParams<TVALUE extends JsonValue = JsonValue> {
+    decisions: AbstractDecisionCollector;
+    candidates: ReadonlyArray<ICandidate<TVALUE>>;
+    index?: number;
+}
+
+/**
+ * Parameters for creating a {@link Conditions.ConditionCollector | ConditionCollector}.
+ * @public
+ */
+declare interface IConditionCollectorCreateParams {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | ReadOnlyQualifierCollector} used to
+     * create conditions in this collector.
+     */
+    qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * Optional array of condition declarations to add to the collector.
+     */
+    conditions?: IConditionDecl[];
+}
+
+/**
+ * Non-validated declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare interface IConditionDecl {
+    qualifierName: string;
+    value: string;
+    operator?: ConditionOperator;
+    priority?: number;
+    scoreAsDefault?: number;
+}
+
+/**
+ * Conversion context to uses when converting
+ * a {@link Conditions.IValidatedConditionDecl | validated condition declaration}.
+ * @public
+ */
+declare interface IConditionDeclConvertContext {
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    conditionIndex?: number;
+}
+
+/**
+ * Parameters for creating a {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+ * @public
+ */
+declare interface IConditionSetCollectorCreateParams {
+    /**
+     * The {@link Conditions.ConditionCollector | ConditionCollector} used to create conditions
+     * for conditions in this collector.
+     */
+    conditions: ConditionCollector;
+    /**
+     * Optional array of {@link Conditions.IConditionSetDecl | condition set declarations} to add to
+     * the collector.
+     */
+    conditionSets?: IConditionSetDecl[];
+}
+
+/**
+ * Non-validated declaration of a {@link Conditions.ConditionSet | set of conditions}.
+ * @public
+ */
+declare interface IConditionSetDecl {
+    conditions: IConditionDecl[];
+}
+
+/**
+ * Context for converting a {@link Conditions.IConditionSetDecl | condition set declaration}
+ * into an instantiated {@link Conditions.ConditionSet | condition set} object.
+ * @public
+ */
+declare interface IConditionSetDeclConvertContext {
+    readonly conditions: ConditionCollector;
+    conditionSetIndex?: number;
+}
+
+/**
+ * The values needed to create a {@link ConditionToken | condition token}.
+ * @public
+ */
+declare interface IConditionTokenParts {
+    qualifier?: string;
+    value: string;
+}
+
+/**
+ * Represents a decision, which is comprised of zero or more
+ * {@link Decisions.Candidate | candidates}, each of which represents a possible
+ * value for some resource, along with the conditions under which that value is valid.
+ * @public
+ */
+declare interface IDecision<TVALUE extends JsonValue = JsonValue> {
+    key: DecisionKey;
+    candidates: ReadonlyArray<ICandidate<TVALUE>>;
+    index?: DecisionIndex;
+}
+
+/**
+ * Parameters used to construct a new {@link Decisions.Decision | Decision} with
+ * the protected constructor.
+ * @public
+ */
+declare interface IDecisionConstructorParams<TVALUE extends JsonValue = JsonValue> extends IDecisionCreateParams<TVALUE> {
+    isAbstract: boolean;
+}
+
+/**
+ * Parameters used to create a new {@link Decisions.Decision | Decision}
+ * with the {@link Decisions.Decision.createDecision | createDecision}
+ * static method.
+ * @public
+ */
+declare interface IDecisionCreateParams<TVALUE extends JsonValue = JsonValue> {
+    candidates: ReadonlyArray<ICandidate<TVALUE>>;
+    index?: number;
+}
+
+/**
+ * @internal
+ */
+declare const identifier: RegExp;
+
+/**
+ * @internal
+ */
+declare const identifierList: RegExp;
+
+/**
+ * Parameters for creating a {@link Import.Importers.FsItemImporter | FsItemImporter}.
+ * @public
+ */
+declare interface IFsItemImporterCreateParams {
+    qualifiers: IReadOnlyQualifierCollector;
+}
+
+/**
+ * Interface describing some single file system item.
+ * @public
+ */
+declare interface IFsItemProps {
+    /**
+     * The underlying `FileTreeItem` for this item.
+     */
+    readonly item: FileTree.FileTreeItem;
+    /**
+     * The base name of the file system item, once
+     * any conditions set tokens have been removed.
+     */
+    readonly baseName: string;
+    /**
+     * {@link Conditions.IValidatedConditionDecl | Conditions} extracted
+     * from the base name of the {@link Import.FsItem | FsItem}.
+     */
+    readonly conditions: Conditions.IValidatedConditionDecl[];
+}
+
+/**
+ * Base interface for importable entities.
+ * @public
+ */
+declare interface IImportable {
+    type: string;
+    context?: ImportContext;
+}
+
+/**
+ * Represents a filesystem item to be imported.
+ * @public
+ */
+declare interface IImportableFsItem extends IImportable {
+    type: 'fsItem';
+    item: FsItem;
+    context?: ImportContext;
+}
+
+/**
+ * Represents some JSON to be imported.
+ * @public
+ */
+declare interface IImportableJson extends IImportable {
+    type: 'json';
+    json: JsonValue;
+    context?: ImportContext;
+}
+
+/**
+ * Represents a filesystem path to be imported.
+ * @public
+ */
+declare interface IImportablePath extends IImportable {
+    type: 'path';
+    path: string;
+    context?: ImportContext;
+}
+
+/**
+ * Represents a resource collection to be imported.
+ * @public
+ */
+declare interface IImportableResourceCollection extends IImportable {
+    type: 'resourceCollection';
+    collection: ResourceJson.ResourceDeclCollection;
+    context?: ImportContext;
+}
+
+/**
+ * Represents a resource tree to be imported.
+ * @public
+ */
+declare interface IImportableResourceTree extends IImportable {
+    type: 'resourceTree';
+    tree: ResourceJson.ResourceDeclTree;
+    context?: ImportContext;
+}
+
+/**
+ * Accumulated context of a resource import operation.
+ * @public
+ */
+declare interface IImportContext {
+    /**
+     * Base ID for the import context for resources imported
+     * in this context.
+     */
+    readonly baseId?: string;
+    /**
+     * Conditions to be applied to resources imported in this context.
+     */
+    readonly conditions?: ReadonlyArray<IConditionDecl>;
+}
+
+/**
+ * Generic interface for an importer than accepts a typed
+ * {@link Import.IImportable | importable} item, extracts any resources
+ * or candidates from it, and returns an optional list of
+ * additional importable items derived from the original.
+ * @public
+ */
+declare interface IImporter {
+    /**
+     * The types of {@link Import.Importable | importable} items that this importer can process.
+     */
+    readonly types: ReadonlyArray<string>;
+    /**
+     * Imports an item, extracting any resources or candidates from it and returns an optional
+     * list of additional importable items derived from it.
+     * @param item - The {@link Import.IImportable | importable} item to import.
+     * @param manager - The {@link Resources.ResourceManager | resource manager} to use for the import.
+     * @returns `Success` with a list of additional importable items derived from the original, or
+     * `Failure` with an error message and a {@link Import.Importers.ImporterResultDetail | result detail}.
+     */
+    import(item: IImportable, manager: ResourceManager): DetailedResult<IImportable[], ImporterResultDetail>;
+}
+
+/**
+ * Parameters for creating an {@link  Import.ImportManager | ImportManager}.
+ * @public
+ */
+declare interface IImporterCreateParams {
+    /**
+     * The {@link Resources.ResourceManager | resource manager} into which resources
+     * will be imported.
+     */
+    resources: ResourceManager;
+    /**
+     * An optional initial {@link Import.ImportContext | import context} for the import operation.
+     */
+    initialContext?: ImportContext;
+    /**
+     * An optional `FileTree` for importing path items.
+     */
+    fileTree?: FileTree.FileTree;
+    /**
+     * An optional list of {@link Import.Importers.IImporter | importers} to use for the import.
+     */
+    importers?: IImporter[];
+}
+
+/**
+ * Parameters to create a {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
+ * @public
+ */
+declare interface IJsonResourceTypeCreateParams {
+    /**
+     * Optional key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
+     * Defaults to 'json'.
+     */
+    key?: string;
+    /**
+     * Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType}
+     * instance.
+     */
+    index?: number;
+}
+
+/**
+ * Interface defining the parameters that can be used to create a new
+ * {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}.
+ * @public
+ */
+declare interface ILanguageQualifierTypeCreateParams extends Partial<IQualifierTypeCreateParams> {
+    /**
+     * Optional name for the qualifier type. Defaults to 'language'.
+     */
+    name?: string;
+    /**
+     * Optional flag indicating whether the context can be a list of values.
+     * Defaults to `true`.
+     */
+    allowContextList?: boolean;
+}
+
+/**
+ * Interface defining the parameters that can be used to create a new
+ * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
+ * @public
+ */
+declare interface ILiteralQualifierTypeCreateParams {
+    /**
+     * Optional name for the qualifier type. Defaults to 'literal'.
+     */
+    name?: string;
+    /**
+     * Optional flag indicating whether the context can be a list of values.
+     * Defaults to `true`.
+     */
+    allowContextList?: boolean;
+    /**
+     * Optional flag indicating whether the match should be case-sensitive. Defaults to false.
+     */
+    caseSensitive?: boolean;
+    /**
+     * Optional array of enumerated values to further constrain the type. Defaults to no
+     * constraint.
+     */
+    enumeratedValues?: ReadonlyArray<string>;
+    /**
+     * Global index for this qualifier type.
+     */
+    index?: number;
+}
+
+/**
+ * Non-validated loose declaration of a {@link Conditions.Condition | condition}.
+ * @public
+ */
+declare interface ILooseConditionDecl {
+    /**
+     * The name of the {@link Qualifiers.Qualifier | qualifier} to be compared.
+     */
+    qualifierName: string;
+    /**
+     * The value to be compared.
+     */
+    value: string;
+    /**
+     * The operator to be used in the comparison.
+     * Default is 'matches'.
+     */
+    operator?: ConditionOperator;
+    /**
+     * The priority of the condition. Default is the default priority for the qualifier.
+     */
+    priority?: number;
+    /**
+     * The score to be used if the condition is used as a default.
+     */
+    scoreAsDefault?: number;
+}
+
+/**
+ * Non-validated loose declaration of a {@link Resources.ResourceCandidate | resource candidate}.
+ * @public
+ */
+declare interface ILooseResourceCandidateDecl extends IChildResourceCandidateDecl {
+    /**
+     * The {@link ResourceId | id} of the resource.
+     */
+    readonly id: string;
+    /**
+     * The JSON value of the resource.
+     */
+    readonly json: JsonObject;
+    /**
+     * The conditions that must be met for the resource to be selected.
+     */
+    readonly conditions?: ConditionSetDecl;
+    /**
+     * If true, the resource is only a partial representation of the full resource.
+     */
+    readonly isPartial?: boolean;
+    /**
+     * The merge method to be used when merging the resource into the existing resource.
+     * default is 'augment'.
+     */
+    readonly mergeMethod?: ResourceValueMergeMethod;
+    /**
+     * The type of the resource.
+     */
+    readonly resourceTypeName?: string;
+}
+
+/**
+ * Normalized non-validated loose declaration of a {@link Resources.ResourceCandidate | resource candidate}.
+ * @public
+ */
+declare interface ILooseResourceCandidateDecl_2 extends IChildResourceCandidateDecl_2 {
+    /**
+     * The {@link ResourceId | id} of the resource.
+     */
+    readonly id: string;
+    /**
+     * The JSON value of the resource.
+     */
+    readonly json: JsonObject;
+    /**
+     * The conditions that must be met for the resource to be selected.
+     */
+    readonly conditions?: ConditionSetDecl_2;
+    /**
+     * If true, the resource is only a partial representation of the full resource.
+     */
+    readonly isPartial?: boolean;
+    /**
+     * The merge method to be used when merging the resource into the existing resource.
+     * default is 'augment'.
+     */
+    readonly mergeMethod?: ResourceValueMergeMethod;
+    /**
+     * The type of the resource.
+     */
+    readonly resourceTypeName?: string;
+}
+
+/**
+ * Non-validated loose declaration of a {@link Resources.Resource | resource}.
+ * @public
+ */
+declare interface ILooseResourceDecl extends IChildResourceDecl {
+    /**
+     * The id of the resource.
+     */
+    readonly id: string;
+    /**
+     * The name of the type of this resource.
+     */
+    readonly resourceTypeName: string;
+    /**
+     * Possible candidates for this value.
+     */
+    readonly candidates?: ReadonlyArray<IChildResourceCandidateDecl>;
+}
+
+/**
+ * Normalized non-validated loose declaration of a {@link Resources.Resource | resource}.
+ * @public
+ */
+declare interface ILooseResourceDecl_2 extends IChildResourceDecl_2 {
+    /**
+     * The id of the resource.
+     */
+    readonly id: string;
+    /**
+     * The name of the type of this resource.
+     */
+    readonly resourceTypeName: string;
+    /**
+     * Possible candidates for this value.
+     */
+    readonly candidates?: ReadonlyArray<IChildResourceCandidateDecl_2>;
+}
+
+declare namespace Import {
+    export {
+        Importers,
+        IImportContext,
+        IValidatedImportContext,
+        ImportContext,
+        isImportable,
+        IImportable,
+        IImportablePath,
+        IImportableFsItem,
+        IImportableJson,
+        IImportableResourceCollection,
+        IImportableResourceTree,
+        Importable,
+        FsItemResultDetail,
+        IFsItemProps,
+        FsItem,
+        IImporterCreateParams,
+        ImportManager
+    }
+}
+export { Import }
+
+/**
+ * Type of importable entities.
+ * @public
+ */
+declare type Importable = IImportablePath | IImportableFsItem | IImportableJson | IImportableResourceCollection | IImportableResourceTree;
+
+/**
+ * Class to accumulate context for a resource import operation.
+ * @public
+ */
+declare class ImportContext implements IValidatedImportContext {
+    /**
+     * {@inheritdoc Import.IImportContext.baseId}
+     */
+    readonly baseId: ResourceId | undefined;
+    /**
+     * {@inheritdoc Import.IImportContext.conditions}
+     */
+    readonly conditions: ReadonlyArray<IConditionDecl>;
+    /**
+     * Protected {@link Import.ImportContext | import context} for derived classes.
+     * Public consumers use {@link Import.ImportContext.create | create} to create new instances.
+     * @param baseId - The base ID for the import context.
+     * @param conditions - Conditions to be applied to resources imported in this context.
+     */
+    protected constructor({ baseId, conditions }: IImportContext);
+    /**
+     * Factory method to create a new {@link Import.ImportContext | import context}.
+     * @param context - The {@link Import.IImportContext | import context} to create
+     * the new context from.
+     * @returns `Success` with the new {@link Import.ImportContext | import context}
+     * if successful, or `Failure` with an error message if creation fails.
+     */
+    static create(context?: IImportContext): Result<ImportContext>;
+    /**
+     * Adds conditions to the import context.
+     * @param conditions - Conditions to be added to the import context.
+     * @returns `Success` with a new {@link Import.ImportContext | import context} containing the added conditions
+     * if successful, or `Failure` with an error message if the operation fails.
+     */
+    withConditions(conditions: IConditionDecl[]): Result<ImportContext>;
+    /**
+     * Appends names to the base ID of the import context.
+     * @param name - The base name to set.
+     * @returns `Success` with a new {@link Import.ImportContext | import context} containing the new base ID
+     * if successful, or `Failure` with an error message if the operation fails.
+     */
+    withName(...names: string[]): Result<ImportContext>;
+    /**
+     * Extends the import context with additional name segments and conditions.
+     * @param context - The {@link Import.IImportContext | import context} to extend this context with.
+     * @returns `Success` with a new {@link Import.ImportContext | import context}
+     * containing the extended context if successful, or `Failure` with an error
+     * message if the operation fails.
+     */
+    extend(context?: IValidatedImportContext): Result<ImportContext>;
+}
+
+/**
+ * Possible results of an import operation.
+ * @public
+ */
+declare type ImporterResultDetail = 'consumed' | 'processed' | 'skipped' | 'failed';
+
+declare namespace Importers {
+    export {
+        ImporterResultDetail,
+        IImporter,
+        CollectionImporter,
+        IFsItemImporterCreateParams,
+        FsItemImporter,
+        JsonImporter,
+        IPathImporterCreateParams,
+        PathImporter
+    }
+}
+
+/**
+ * Class to manage the import of resources from various sources.
+ * @public
+ */
+declare class ImportManager {
+    /**
+     * The {@link Resources.ResourceManager | resource manager} into which resources
+     * will be imported.
+     */
+    readonly resources: ResourceManager;
+    /**
+     * The list of {@link Import.Importers.IImporter | importers} to use for the
+     * import operations.
+     */
+    get importers(): ReadonlyArray<IImporter>;
+    /**
+     * The initial {@link Import.ImportContext | import context} for the import operation.
+     */
+    initialContext: ImportContext;
+    protected _stack: IImportable[];
+    protected _importers: IImporter[];
+    /**
+     * Protected constructor for the {@link Import.ImportManager | ImportManager}.
+     * @param params - Parameters for creating the {@link Import.ImportManager | ImportManager}.
+     */
+    protected constructor(params: IImporterCreateParams);
+    /**
+     * Factory method to create a new {@link Import.ImportManager | ImportManager}.
+     * @param params - Parameters for creating the {@link Import.ImportManager | ImportManager}.
+     * @returns `Success` with the new {@link Import.ImportManager | ImportManager}
+     * if successful, or `Failure` with an error message if creation fails.
+     */
+    static create(params: IImporterCreateParams): Result<ImportManager>;
+    /**
+     * Imports resources from an {@link Import.IImportable | importable} object.
+     * @param importable - The {@link Import.IImportable | importable} object to import.
+     * @returns `Success` with the {@link Import.ImportManager | ImportManager} if successful,
+     * or `Failure` with an error message if the import fails.
+     */
+    import(importable: IImportable): Result<ImportManager>;
+    /**
+     * Imports resources from a file system path.
+     * @param filePath - The path to import resources from.
+     * @returns `Success` with the {@link Import.ImportManager | ImportManager} if successful,
+     * or `Failure` with an error message if the import fails.
+     */
+    importFromFileSystem(filePath: string): Result<ImportManager>;
+    /**
+     * Gets the default importers using supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers}
+     * and optional `FileTree`.
+     * @param qualifiers - The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} to use for the import.
+     * @param tree - An optional `FileTree` for importing path items.
+     * @returns A read-only array of {@link Import.Importers.IImporter | importers}.
+     */
+    static getDefaultImporters(qualifiers: IReadOnlyQualifierCollector, tree?: FileTree.FileTree): ReadonlyArray<IImporter>;
+    /**
+     * Imports any items on the import stack.
+     * @returns `Success` with the {@link Import.ImportManager | ImportManager} if successful,
+     * or `Failure` with an error message if the import fails.
+     * @public
+     */
+    protected _import(): Result<ImportManager>;
+}
+
+/**
+ * Parameters for creating a {@link Import.Importers.PathImporter | PathImporter}.
+ * @public
+ */
+declare interface IPathImporterCreateParams {
+    qualifiers: IReadOnlyQualifierCollector;
+    tree?: FileTree.FileTree;
+    ignoreFileTypes?: string[];
+}
+
+/**
+ * Parameters for creating a new {@link Qualifiers.QualifierCollector}.
+ * @public
+ */
+declare interface IQualifierCollectorCreateParams {
+    /**
+     * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} used to
+     * create {@link Qualifiers.Qualifier | qualifiers} from {@link Qualifiers.IQualifierDecl | declarations}.
+     */
+    qualifierTypes: ReadOnlyQualifierTypeCollector;
+    /**
+     * Optional list of {@link Qualifiers.IQualifierDecl | declarations} for the qualifiers to add to the collection
+     * upon creation.
+     */
+    qualifiers?: IQualifierDecl[];
+}
+
+/**
+ * Context necessary to convert a string or number to a
+ * {@link Qualifiers.Qualifier | Qualifier} object.
+ * @public
+ */
+declare interface IQualifierConvertContext {
+    qualifiers: IReadOnlyQualifierCollector;
+}
+
+/**
+ * Simple declaration for a {@link Qualifiers.Qualifier | Qualifier}.
+ * @public
+ */
+declare interface IQualifierDecl {
+    name: string;
+    typeName: string;
+    defaultPriority: number;
+    token?: string;
+    tokenIsOptional?: boolean;
+}
+
+/**
+ * Context necessary to convert a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}.
+ * @public
+ */
+declare interface IQualifierDeclConvertContext {
+    readonly qualifierTypes: ReadOnlyQualifierTypeCollector;
+    qualifierIndex?: number;
+}
+
+/**
+ * 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
+ */
+declare interface IQualifierType extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
+    /**
+     * The name of the qualifier type.
+     */
+    readonly name: QualifierTypeName;
+    /**
+     * Unique key for this qualifier.
+     */
+    readonly key: QualifierTypeName;
+    /**
+     * Global index for this qualifier type. Immutable once set, either at
+     * construction or using {@link QualifierTypes.IQualifierType.setIndex | setIndex}.
+     */
+    readonly index: QualifierTypeIndex | undefined;
+    /**
+     * Validates a condition value for this qualifier type.
+     * @param value - The string value to validate.
+     * @returns `Success` with the {@link QualifierConditionValue | validated value} if the value
+     * is valid for use in a condition, `Failure` with error details otherwise.
+     */
+    isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Validates a context value for this qualifier type.
+     * @param value - The string value to validate.
+     * @returns `Success` with the {@link QualifierContextValue | validated value} if the value
+     * is valid for use in a runtime context, `Failure` with error details otherwise.
+     */
+    isValidContextValue(value: string): value is QualifierContextValue;
+    /**
+     * Validates that a value and optional operator are valid for use in a condition
+     * for qualifiers of this type.
+     * @param value - The string value to validate.
+     * @param operator - An optional operator to validate. Defaults to 'matches'.
+     */
+    validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue>;
+    /**
+     * Validates that a value is valid for use in a runtime context for qualifiers of this type.
+     * @param value - The string value to validate.
+     * @returns `Success` with the {@link QualifierContextValue | validated value} if the value
+     * is valid for use in a runtime context, `Failure` with error details otherwise.
+     */
+    validateContextValue(value: string): Result<QualifierContextValue>;
+    /**
+     * Determines the extent to which a condition matches a context value for this qualifier type.
+     * @param condition - The condition value to evaluate.
+     * @param context - The context value to evaluate.
+     * @param operator - The operator to use in evaluating the match.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
+     * matches the context value.
+     */
+    matches(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * Sets the index for this qualifier type.  Once set, index is
+     * immutable.
+     */
+    setIndex(index: number): Result<QualifierTypeIndex>;
+}
+
+/**
+ * Parameters for creating a new {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector}.
+ * @public
+ */
+declare interface IQualifierTypeCollectorCreateParams {
+    /**
+     * Optional list of {@link QualifierTypes.QualifierType | QualifierTypes} to add to the collector
+     * on creation.
+     */
+    qualifierTypes?: QualifierType[];
+}
+
+/**
+ * Context necessary to convert a qualifier name or number to an
+ * instantiated {@link QualifierTypes.QualifierType}.
+ * @public
+ */
+declare interface IQualifierTypeConvertContext {
+    qualifierTypes: ReadOnlyQualifierTypeCollector;
+}
+
+/**
+ * Parameters used to create a base {@link QualifierTypes.QualifierType | qualifier type}.
+ * @public
+ */
+declare interface IQualifierTypeCreateParams {
+    /**
+     * The name of the qualifier type. No default value.
+     */
+    name: string;
+    /**
+     * Global index for this qualifier type.
+     */
+    index?: number;
+    /**
+     * Flag indicating whether this qualifier type allows a list of values in a context.
+     * Defaults to `false`.
+     */
+    allowContextList?: boolean;
+}
+
+/**
+ * Readonly version of {@link Qualifiers.QualifierCollector | QualifierCollector}.
+ * @public
+ */
+declare interface IReadOnlyQualifierCollector extends Collections.IReadOnlyValidatingCollector<Qualifier> {
+    /**
+     * {@inheritdoc Qualifiers.QualifierCollector.qualifierTypes}
+     */
+    readonly qualifierTypes: ReadOnlyQualifierTypeCollector;
+    /**
+     * Gets a {@link Qualifiers.Qualifier | qualifier} by name or token.
+     * @param nameOrToken - The name or token of the qualifier to retrieve.
+     * @returns `Success` with the qualifier if found, or `Failure` if not.
+     */
+    getByNameOrToken(nameOrToken: string): Result<Qualifier>;
+    /**
+     * Checks if a qualifier with a given name or token is in the collection.
+     * @param nameOrToken - The name or token of the qualifier to check.
+     * @returns `true` if the qualifier is in the collection, `false` if not.
+     */
+    hasNameOrToken(nameOrToken: string): boolean;
+}
+
+/**
+ * Parameters for creating a {@link Resources.ResourceBuilder}.
+ * @public
+ */
+declare interface IResourceBuilderCreateParams {
+    id: string;
+    typeName?: string;
+    conditionSets: ConditionSetCollector;
+    resourceTypes: ReadOnlyResourceTypeCollector;
+}
+
+/**
+ * Parameters to create a {@link Resources.ResourceCandidate | ResourceCandidate}.
+ * @public
+ */
+declare interface IResourceCandidateCreateParams {
+    id: string;
+    decl: ResourceJson.Json.IChildResourceCandidateDecl;
+    resourceType?: ResourceType;
+    parentConditions?: ReadonlyArray<Condition>;
+    conditionSets: ConditionSetCollector;
+}
+
+/**
+ * Non-validated declaration of a collection of resources.
+ * @public
+ */
+declare interface IResourceCollectionDecl {
+    readonly baseName?: string;
+    readonly baseConditions?: ConditionSetDecl;
+    readonly candidates?: ReadonlyArray<ILooseResourceCandidateDecl>;
+    readonly resources?: ReadonlyArray<ILooseResourceDecl>;
+    readonly collections?: ReadonlyArray<IResourceCollectionDecl>;
+}
+
+/**
+ * Normalized non-validated declaration of a collection of resources.
+ * @public
+ */
+declare interface IResourceCollectionDecl_2 {
+    readonly baseName?: string;
+    readonly baseConditions?: ConditionSetDecl_2;
+    readonly candidates?: ReadonlyArray<ILooseResourceCandidateDecl_2>;
+    readonly resources?: ReadonlyArray<ILooseResourceDecl_2>;
+    readonly collections?: ReadonlyArray<IResourceCollectionDecl_2>;
+}
+
+/**
+ * Parameters for creating a {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector}.
+ * @public
+ */
+declare interface IResourceCollectorCreateParams {
+    resourceTypes?: ResourceType[];
+}
+
+/**
+ * Parameters used to create a {@link Resources.Resource | Resource} object.
+ * @public
+ */
+declare interface IResourceCreateParams {
+    /**
+     * The id of the resource.
+     */
+    id?: string;
+    /**
+     * Optional {@link ResourceTypes.ResourceType | type} of the resource. If not specified, the type will be inferred
+     * from the candidates.
+     */
+    resourceType?: ResourceType;
+    /**
+     * Array of {@link Resources.ResourceCandidate | candidates} for the resource.
+     */
+    candidates: ReadonlyArray<ResourceCandidate>;
+}
+
+/**
+ * Generic container for resource and resource candidate
+ * declarations.
+ * @public
+ */
+declare interface IResourceDeclContainer {
+    getLooseResources(): ReadonlyArray<Normalized.ILooseResourceDecl>;
+    getLooseCandidates(): ReadonlyArray<Normalized.ILooseResourceCandidateDecl>;
+}
+
+/**
+ * Interface for parameters to the {@link Resources.ResourceManager.create | ResourceManager create method}.
+ * @public
+ */
+declare interface IResourceManagerCreateParams {
+    qualifiers: IReadOnlyQualifierCollector;
+    resourceTypes: ReadOnlyResourceTypeCollector;
+}
+
+/**
+ * Normalized non-validated declaration of a {@link Resources.Resource | resource} tree node.
+ * @public
+ */
+declare interface IResourceTreeChildNodeDecl {
+    readonly resources?: Record<string, IChildResourceDecl>;
+    readonly children?: Record<string, IResourceTreeChildNodeDecl>;
+}
+
+/**
+ * Normalized non-validated declaration of a {@link Resources.Resource | resource} tree node.
+ * @public
+ */
+declare interface IResourceTreeChildNodeDecl_2 {
+    readonly resources?: Record<string, IChildResourceDecl_2>;
+    readonly children?: Record<string, IResourceTreeChildNodeDecl_2>;
+}
+
+/**
+ * Normalized non-validated declaration of a {@link Resources.Resource | resource} tree root.
+ * @public
+ */
+declare interface IResourceTreeRootDecl extends IResourceTreeChildNodeDecl {
+    readonly baseName?: string;
+    readonly resources?: Record<string, IChildResourceDecl>;
+    readonly children?: Record<string, IResourceTreeChildNodeDecl>;
+}
+
+/**
+ * Normalized non-validated declaration of a {@link Resources.Resource | resource} tree root.
+ * @public
+ */
+declare interface IResourceTreeRootDecl_2 extends IResourceTreeChildNodeDecl_2 {
+    readonly baseName?: string;
+    readonly resources?: Record<string, IChildResourceDecl_2>;
+    readonly children?: Record<string, IResourceTreeChildNodeDecl_2>;
+}
+
+/**
+ * Type guard for {@link Import.Importable | importables}.
+ * @param i - The entity to check.
+ * @returns `true` if the supplied {@link Import.IImportable | IImportable} is a
+ * {@link Import.Importable | known importable}, `false` otherwise.
+ * @public
+ */
+declare function isImportable(i: IImportable): i is Importable;
+
+/**
+ * Determines whether a number is a valid condition index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid condition index, false otherwise.
+ * @public
+ */
+declare function isValidConditionIndex(index: number): index is ConditionIndex;
+
+/**
+ * Determines whether a string is a valid condition key.  A condition key has
+ * the format:
+ * `<qualifierName>(-<operator>)?-[<value>]@<priority>`
+ * where operator is omitted for the default 'matches' operator.
+ * @param key - the string to validate
+ * @returns `true` if the string is a valid condition key, `false` otherwise.
+ * @public
+ */
+declare function isValidConditionKey(key: string): key is ConditionKey;
+
+/**
+ * Determines whether a string is a valid condition operator.
+ * @param operator - the string to validate
+ * @returns true if the string is a valid condition operator, false otherwise.
+ * @public
+ */
+declare function isValidConditionOperator(operator: string): operator is ConditionOperator;
+
+/**
+ * Determines whether a number is a valid priority.
+ * @param priority - the number to validate
+ * @returns true if the number is a valid priority, false otherwise.
+ * @public
+ */
+declare function isValidConditionPriority(priority: number): priority is ConditionPriority;
+
+/**
+ * Determines whether a string is a valid condition set hash.
+ * @param hash - the string to validate.
+ * @returns `true` if the string is a valid condition set hash, `false` otherwise.
+ * @public
+ */
+declare function isValidConditionSetHash(hash: string): hash is ConditionSetHash;
+
+/**
+ * Determines whether a number is a valid condition set index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid condition set index, false otherwise.
+ * @public
+ */
+declare function isValidConditionSetIndex(index: number): index is ConditionSetIndex;
+
+/**
+ * Determines whether a string is a valid condition set key.
+ * @param key - the string to validate.
+ * @returns `true` if the string is a valid condition set key, `false` otherwise.
+ * @public
+ */
+declare function isValidConditionSetKey(key: string): key is ConditionSetKey;
+
+/**
+ * Determines whether a string is a valid condition set token.
+ * @param token - the string to validate.
+ * @returns `true` if the string is a valid condition set token, `false` otherwise.
+ * @public
+ */
+declare function isValidConditionSetToken(token: string): token is ConditionSetToken;
+
+/**
+ * Determines whether a string is a valid {@link ConditionToken | condition token}.
+ * A condition token has the format:
+ * `<qualifierName>=<value>` or `<value>`
+ * @param token -
+ * @returns `true` if the string is a valid condition token, `false` otherwise.
+ * @public
+ */
+declare function isValidConditionToken(token: string): token is ConditionToken;
+
+/**
+ * Determines whether a number is a valid decision index.
+ * @param index - the number to validate
+ * @returns `true` if the number is a valid decision index, `false` otherwise.
+ * @public
+ */
+declare function isValidDecisionIndex(index: number): index is DecisionIndex;
+
+/**
+ * Determines whether a string is a valid decision key.
+ * @param key - the string to validate
+ * @returns `true` if the string is a valid decision key, `false` otherwise.
+ * @public
+ */
+declare function isValidDecisionKey(key: string): key is DecisionKey;
+
+/**
+ * Determines whether a number is a valid qualifier index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid qualifier index, false otherwise.
+ * @public
+ */
+declare function isValidQualifierIndex(index: number): index is QualifierIndex;
+
+/**
+ * Determines whether a supplied value is a valid {@link QualifierMatchScore | match score}.
+ * @param value - The value to validate.
+ * @returns - `true` if the value is a valid match score, `false` otherwise.
+ * @public
+ */
+declare function isValidQualifierMatchScore(value: number): value is QualifierMatchScore;
+
+/**
+ * Determines whether a string is a valid qualifier name.
+ * @param name - the string to validate
+ * @returns true if the string is a valid qualifier name, false otherwise.
+ * @public
+ */
+declare function isValidQualifierName(name: string): name is QualifierName;
+
+/**
+ * Determines whether a number is a valid qualifier type index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid qualifier type index, false otherwise.
+ * @public
+ */
+declare function isValidQualifierTypeIndex(index: number): index is QualifierTypeIndex;
+
+/***
+ * Determines whether a string is a valid qualifier type name.
+ * @param name - the string to validate
+ * @returns true if the string is a valid qualifier type name, false otherwise.
+ * @public
+ */
+declare function isValidQualifierTypeName(name: string): name is QualifierTypeName;
+
+/**
+ * Checks if the given ID is a valid resource ID.
+ *
+ * @param id - The ID to validate.
+ * @returns `true` if the ID is a valid resource ID, otherwise `false`.
+ * @public
+ */
+declare function isValidResourceId(id: string): id is ResourceId;
+
+/**
+ * Checks if the given index is a valid resource index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid resource index, otherwise `false`.
+ * @public
+ */
+declare function isValidResourceIndex(index: number): index is ResourceIndex;
+
+/**
+ * Checks if the given name is a valid resource name.
+ *
+ * @param name - The name to validate.
+ * @returns `true` if the name is a valid resource name, otherwise `false`.
+ * @public
+ */
+declare function isValidResourceName(name: string): name is ResourceName;
+
+/**
+ * Checks if the given index is a valid resource type index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid resource type index, otherwise `false`.
+ * @public
+ */
+declare function isValidResourceTypeIndex(index: number): index is ResourceTypeIndex;
+
+/**
+ * Checks if the given name is a valid resource type name.
+ *
+ * @param name - The name to validate.
+ * @returns `true` if the name is a valid resource type name, otherwise `false`.
+ * @public
+ */
+declare function isValidResourceTypeName(name: string): name is ResourceTypeName;
+
+/**
+ * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
+ * @public
+ */
+declare interface ITerritoryQualifierTypeCreateParams {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.name}
+     */
+    name?: string;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.allowContextList}
+     */
+    allowContextList?: boolean;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.index}
+     */
+    index?: number;
+    /**
+     * Optional array enumerating allowed territories to further constrain the type.
+     */
+    allowedTerritories?: string[];
+}
+
+/**
+ * Validated declaration of a {@link Conditions.Condition | condition} with all defaults applied.
+ * @public
+ */
+declare interface IValidatedConditionDecl {
+    qualifier: Qualifier;
+    value: QualifierConditionValue;
+    operator: ConditionOperator;
+    priority: ConditionPriority;
+    scoreAsDefault?: QualifierMatchScore;
+    index?: ConditionIndex;
+}
+
+/**
+ * Validated declaration of a {@link Conditions.ConditionSet | set of conditions}.
+ * @public
+ */
+declare interface IValidatedConditionSetDecl {
+    conditions: ReadonlyArray<Condition>;
+    index?: number;
+}
+
+/**
+ * Accumulated context of a resource import operation.
+ * @public
+ */
+declare interface IValidatedImportContext {
+    /**
+     * Base ID for the import context for resources imported
+     * in this context.
+     */
+    readonly baseId?: ResourceId;
+    /**
+     * Conditions to be applied to resources imported in this context.
+     */
+    readonly conditions: ReadonlyArray<IConditionDecl>;
+}
+
+/**
+ * Validated declaration for a {@link Qualifiers.Qualifier | Qualifier}.
+ * @public
+ */
+declare interface IValidatedQualifierDecl {
+    /**
+     * The name of the qualifier.
+     */
+    name: QualifierName;
+    /**
+     * The token used to identify the qualifier in the name or
+     * path of a resource being imported.
+     */
+    token: QualifierName;
+    /**
+     * The {@link QualifierTypes.QualifierType | type} of the qualifier.
+     */
+    type: QualifierType;
+    /**
+     * The default {@link ConditionPriority | priority} of conditions
+     * that depend on this qualifier.
+     */
+    defaultPriority: ConditionPriority;
+    /**
+     * Indicates whether the token is optional when parsing a resource token.
+     */
+    tokenIsOptional: boolean;
+    /**
+     * Index of the qualifier.
+     */
+    index: QualifierIndex | undefined;
+}
+
+/**
+ * Joins a list of {@link ResourceId | resource ID} or {@link ResourceName | resource name} with
+ * to create a new {@link ResourceId | resource ID}. Returns `undefined` if no names are defined.
+ *
+ * @param base - The base name or ID to join.
+ * @param names - Additional names to join.
+ * @returns `Success` with the new ID if the base and names are valid, `Success` with `undefined`
+ * if names were present, or `Failure` with an error message if the resulting id is invalid.
+ * @public
+ */
+declare function joinOptionalResourceIds(...ids: (string | undefined)[]): Result<ResourceId | undefined>;
+
+/**
+ * Joins a list of {@link ResourceId | resource ID} or {@link ResourceName | resource name} with
+ * to create a new {@link ResourceId | resource ID}. Fails if resulting ID is invalid or empty.
+ *
+ * @param base - The base name or ID to join.
+ * @param names - Additional names to join.
+ * @returns `Success` with the new ID if the base and names are valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function joinResourceIds(...ids: (string | undefined)[]): Result<ResourceId>;
+
+declare namespace Json {
+    export {
+        ILooseConditionDecl,
+        IChildConditionDecl,
+        ConditionSetDeclAsArray,
+        ConditionSetDeclAsRecord,
+        ConditionSetDecl,
+        IChildResourceCandidateDecl,
+        ILooseResourceCandidateDecl,
+        IChildResourceDecl,
+        ILooseResourceDecl,
+        IResourceTreeChildNodeDecl,
+        IResourceTreeRootDecl,
+        IResourceCollectionDecl
+    }
+}
+
+/**
+ * {@link Import.Importers.IImporter | Importer} implementation which imports resources from a JSON object.
+ * @public
+ */
+declare class JsonImporter implements IImporter {
+    /**
+     * {@inheritdoc Import.Importers.IImporter.types}
+     */
+    readonly types: ReadonlyArray<string>;
+    /**
+     * Protected {@link Import.Importers.JsonImporter | JsonImporter} constructor for derived classes.
+     */
+    protected constructor();
+    /**
+     * Creates a new {@link Import.Importers.JsonImporter | JsonImporter} instance.
+     * @returns `Success` with the new {@link Import.Importers.JsonImporter | JsonImporter} if successful,
+     * `Failure` otherwise.
+     */
+    static create(): Result<JsonImporter>;
+    /**
+     * {@inheritdoc Import.Importers.IImporter.import}
+     */
+    import(item: IImportable, manager: ResourceManager): DetailedResult<IImportable[], ImporterResultDetail>;
+    private _tryImportResourceCollection;
+    private _tryImportResourceTree;
+    private _tryImportResource;
+}
+
+/**
+ * Implementation of a {@link ResourceTypes.ResourceType | ResourceType} for JSON values.
+ * @public
+ */
+declare class JsonResourceType extends ResourceType<JsonObject> {
+    /**
+     * Protected {@link ResourceTypes.JsonResourceType | JsonResourceType} constructor for use by subclasses.
+     * Use {@link ResourceTypes.JsonResourceType.create | JsonResourceType.create} to create a new instance.
+     * @param key - The key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
+     * @param index - Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
+     */
+    protected constructor(key: ResourceTypeName, index?: number);
+    /**
+     * Factory method to create a new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
+     * @param params - {@link ResourceTypes.IJsonResourceTypeCreateParams | Parameters} to create the new instance.
+     * @returns `Success` with the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance if successful
+     * or `Failure` with an error message if not.
+     */
+    static create(params?: IJsonResourceTypeCreateParams): Result<JsonResourceType>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validateDeclaration:1)}
+     */
+    validateDeclaration(json: JsonValue, isPartial: true, mergeMethod?: ResourceValueMergeMethod): Result<Partial<JsonObject>>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validateDeclaration:2)}
+     */
+    validateDeclaration(json: JsonValue, isPartial: false, mergeMethod?: ResourceValueMergeMethod): Result<JsonObject>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validateDeclaration:3)}
+     */
+    validateDeclaration(json: JsonValue, isPartial: boolean, mergeMethod?: ResourceValueMergeMethod): Result<JsonObject | Partial<JsonObject>>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validate:1)}
+     */
+    validate(json: JsonObject, isPartial: true): Result<JsonObject>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validate:2)}
+     */
+    validate(json: JsonObject, isPartial: false): Result<JsonObject>;
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.(validate:3)}
+     */
+    validate(json: JsonObject, isPartial: boolean): Result<JsonObject>;
+}
+
+/**
+ * {@link QualifierTypes.QualifierType | Qualifier type} which matches BCP-47 language tags applying
+ * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.
+ * Accepts a list of language tags in the context by default.
+ * @public
+ */
+declare class LanguageQualifierType extends QualifierType {
+    /**
+     * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
+     * @param name - Optional name for the qualifier type. Defaults to 'language'.
+     * @param allowContextList - Optional flag indicating whether the context can be a list of values. Defaults to `true`.
+     * @public
+     */
+    protected constructor({ name, allowContextList, index }: ILanguageQualifierTypeCreateParams);
+    /**
+     * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
+     * @param params - Optional {@link QualifierTypes.ILanguageQualifierTypeCreateParams | parameters} to use when creating
+     * the new instance.
+     * @returns `Success` with the new {@link QualifierTypes.LanguageQualifierType | language qualifier type} if successful, `Failure`
+     * otherwise.
+     */
+    static create(params?: ILanguageQualifierTypeCreateParams): Result<LanguageQualifierType>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Matches a single language condition against a single language context value using
+     * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.
+     * @param condition - The language condition value to match.
+     * @param context - The language context value to match against.
+     * @param operator - The operator to use for the match. Must be 'matches'.
+     * @returns - The match score, or `noMatch` if the match fails.
+     */
+    protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+}
+
+/**
+ * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value., optionally case-sensitive
+ * or matching against an ordered list of values at runtime.
+ * @public
+ */
+declare class LiteralQualifierType extends QualifierType {
+    /**
+     * Indicates whether the qualifier match is case-sensitive.
+     */
+    readonly caseSensitive: boolean;
+    /**
+     * Optional array of enumerated values to further constrain the type.
+     */
+    readonly enumeratedValues?: ReadonlyArray<QualifierConditionValue>;
+    /**
+     * Constructs a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
+     * @param name - Optional name for the qualifier type. Defaults to 'literal'.
+     * @param caseSensitive - Optional flag indicating whether the match should be case-sensitive. Defaults to false.
+     * @param allowContextList - Optional flag indicating whether the context can be a list of values. Defaults to false.
+     * @public
+     */
+    protected constructor({ name, caseSensitive, allowContextList, enumeratedValues, index }: ILiteralQualifierTypeCreateParams);
+    /**
+     * Determines whether a value is a valid condition value for a literal qualifier. The
+     * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts
+     * any identifier as a valid condition value.
+     * @param value - The value to validate.
+     * @returns `true` if the value is a valid condition value, `false` otherwise.
+     */
+    isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     */
+    protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
+     * @param params - Optional {@link QualifierTypes.ILiteralQualifierTypeCreateParams | parameters}
+     * to use when creating the new instance.
+     * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(params?: ILiteralQualifierTypeCreateParams): Result<LiteralQualifierType>;
+    /**
+     * Checks if the given value is a valid literal condition value.
+     * @param from - The value to validate.
+     * @returns `true` if the value is a valid literal condition value, otherwise `false`.
+     * @public
+     */
+    static isValidLiteralConditionValue(from: string): from is QualifierConditionValue;
+    /**
+     * Converts a string to a {@link QualifierConditionValue | literal condition value}.
+     * @param from - The string to convert.
+     * @returns `Success` with the converted value if valid, or `Failure` with an error message
+     * if not.
+     * @public
+     */
+    static toLiteralConditionValue(from: string): Result<QualifierConditionValue>;
+}
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Json.ILooseConditionDecl | loose condition declaration}.
+ * @public
+ */
+declare const looseConditionDecl: Converter<Json.ILooseConditionDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Json.ILooseResourceCandidateDecl | loose resource candidate declaration}.
+ * @public
+ */
+declare const looseResourceCandidateDecl: Converter<Normalized.ILooseResourceCandidateDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.ILooseResourceDecl | loose resource declaration}.
+ * @public
+ */
+declare const looseResourceDecl: Converter<Normalized.ILooseResourceDecl>;
+
+/**
+ * Maximum valid priority for a condition.
+ * @public
+ */
+export declare const MaxConditionPriority: ConditionPriority;
+
+/**
+ * Helper method to merge a child candidate with base conditions.
+ * @param candidate - The candidate to merge.
+ * @param baseConditions - The base conditions to merge with the candidate.
+ * @returns `Success` with the merged candidate if successful, otherwise `Failure`.
+ * @public
+ */
+declare function mergeChildCandidate(candidate: Normalized.IChildResourceCandidateDecl, baseConditions?: ReadonlyArray<Json.ILooseConditionDecl | Conditions.IConditionDecl>): Result<Normalized.IChildResourceCandidateDecl>;
+
+/**
+ * Helper method to merge a child resource with a parent name and conditions.
+ * @param resource - The resource to merge.
+ * @param name - The name of the resource.
+ * @param parentName - The name of the parent resource.
+ * @param parentConditions - The conditions of the parent resource.
+ * @returns `Success` with the merged resource if successful, otherwise `Failure`.
+ * @public
+ */
+declare function mergeChildResource(resource: Normalized.IChildResourceDecl, name: string, parentName?: string, parentConditions?: ReadonlyArray<Json.ILooseConditionDecl | Conditions.IConditionDecl>): Result<Normalized.ILooseResourceDecl>;
+
+/**
+ * Helper method to merge a loose candidate with a base name and conditions.
+ * @param candidate - The candidate to merge.
+ * @param baseName - The base name to merge with the candidate.
+ * @param baseConditions - The base conditions to merge with the candidate.
+ * @returns `Success` with the merged candidate if successful, otherwise `Failure`.
+ * @public
+ */
+declare function mergeLooseCandidate(candidate: Normalized.ILooseResourceCandidateDecl, baseName?: string, baseConditions?: ReadonlyArray<Json.ILooseConditionDecl | Conditions.IConditionDecl>): Result<Normalized.ILooseResourceCandidateDecl>;
+
+/**
+ * Helper method to merge a loose resource with a base name and conditions.
+ * @param resource - The resource to merge.
+ * @param baseName - The base name to merge with the resource.
+ * @param baseConditions - The base conditions to merge with the resource.
+ * @returns `Success` with the merged resource if successful, otherwise `Failure`.
+ * @public
+ */
+declare function mergeLooseResource(resource: Normalized.ILooseResourceDecl, baseName?: string, baseConditions?: ReadonlyArray<Json.ILooseConditionDecl | Conditions.IConditionDecl>): Result<Normalized.ILooseResourceDecl>;
+
+/**
+ * Minimum valid priority for a condition.
+ * @public
+ */
+export declare const MinConditionPriority: ConditionPriority;
+
+/**
+ * {@link QualifierMatchScore | Match score} indicating no match.
+ * @public
+ */
+export declare const NoMatch: QualifierMatchScore;
+
+declare namespace Normalized {
+    export {
+        ConditionSetDecl_2 as ConditionSetDecl,
+        IChildResourceCandidateDecl_2 as IChildResourceCandidateDecl,
+        ILooseResourceCandidateDecl_2 as ILooseResourceCandidateDecl,
+        IChildResourceDecl_2 as IChildResourceDecl,
+        ILooseResourceDecl_2 as ILooseResourceDecl,
+        IResourceTreeChildNodeDecl_2 as IResourceTreeChildNodeDecl,
+        IResourceTreeRootDecl_2 as IResourceTreeRootDecl,
+        IResourceCollectionDecl_2 as IResourceCollectionDecl
+    }
+}
+
+/**
+ * Parses a condition set token string into an array of {@link Helpers.IConditionTokenParts | condition token parts}.
+ * @param token - the conditions set token string to parse.
+ * @returns `Success` with the parts if successful, `Failure` with an error message if not.
+ * @public
+ */
+declare function parseConditionSetTokenParts(token: string): Result<IConditionTokenParts[]>;
+
+/**
+ * Parses a condition token string into its {@link Helpers.IConditionTokenParts | parts}.
+ * @param token - the token string to parse.
+ * @returns `Success` with the parts if successful, `Failure` with an error message if not.
+ * @public
+ */
+declare function parseConditionTokenParts(token: string): Result<IConditionTokenParts>;
+
+/**
+ * {@link Import.Importers.IImporter | Importer} implementation which imports resources from a `FileTree`
+ * given a path.
+ * @public
+ */
+declare class PathImporter implements IImporter {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use for this importer.
+     */
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * The `FileTree` from which resources will be imported.
+     */
+    readonly tree: FileTree.FileTree;
+    /**
+     * The types of {@link Import.IImportable | importables} that this importer can handle.
+     */
+    readonly types: ReadonlyArray<string>;
+    /**
+     * The types of files to ignore when importing.  Any file not ignored is converted
+     * to an {@link Import.IImportableFsItem | IImportableFsItem}.
+     */
+    readonly ignoreFileTypes: string[];
+    /**
+     * Protected constructor for the {@link Import.Importers.PathImporter | PathImporter}.
+     * @param params - Parameters for creating the {@link Import.Importers.PathImporter | PathImporter}.
+     */
+    protected constructor(params: IPathImporterCreateParams);
+    /**
+     * Creates a new {@link Import.Importers.PathImporter | PathImporter}.
+     * @param params - Parameters for creating the {@link Import.Importers.PathImporter | dirPathImporter}.
+     * @returns `Success` with the new `PathImporter` if successful, `Failure` with an error message if not.
+     */
+    static create(params: IPathImporterCreateParams): Result<PathImporter>;
+    /**
+     * {@inheritdoc Import.Importers.IImporter.import}
+     */
+    import(item: IImportable, __manager: ResourceManager): DetailedResult<IImportable[], ImporterResultDetail>;
+    /**
+     * Gets an {@link Import.FsItem | FsItem} from an {@link Import.IImportable | importable}.
+     * @param item - The importable to convert.
+     * @returns `Success` containing the `FsItem` if successful, `Failure` with an error message if not.
+     */
+    protected _getFileTreeItemFromImportable(item: IImportable): DetailedResult<FsItem, FsItemResultDetail>;
+}
+
+/**
+ * {@link QualifierMatchScore | Match score} indicating a perfect match.
+ * @public
+ */
+export declare const PerfectMatch: QualifierMatchScore;
+
+/**
+ * Represents a qualifier that can be used to identify the context in
+ * which a resource is used.
+ * @public
+ */
+declare class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {
+    /**
+     * The name of the qualifier.
+     */
+    readonly name: QualifierName;
+    /**
+     * The token used to identify the qualifier in the name or
+     * path of a resource being imported.
+     */
+    readonly token: QualifierName;
+    /**
+     * The {@link QualifierTypes.QualifierType | type} of the qualifier.
+     */
+    readonly type: QualifierType;
+    /**
+     * Indicates whether the token is optional in the name or path of a resource being imported.
+     */
+    readonly tokenIsOptional: boolean;
+    /**
+     * The index of the qualifier.
+     */
+    get index(): QualifierIndex | undefined;
+    /**
+     * The collector key for this qualifier.
+     */
+    get key(): QualifierName;
+    /**
+     * The default {@link ConditionPriority | priority} of conditions
+     * that depend on this qualifier.
+     */
+    readonly defaultPriority: ConditionPriority;
+    protected readonly _collectible: Collections.Collectible<QualifierName, QualifierIndex>;
+    /**
+     * Constructs a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the
+     * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.
+     * @param name - The name of the qualifier.
+     * @param type - The {@link QualifierTypes.QualifierType | type} of the qualifier.
+     * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions
+     * @public
+     */
+    protected constructor({ name, token, type, defaultPriority, tokenIsOptional, index }: IValidatedQualifierDecl);
+    /**
+     * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the
+     * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.
+     * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}
+     * for the new instance.
+     * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(decl: IValidatedQualifierDecl): Result<Qualifier>;
+    /**
+     * Sets the index of this qualifier.  Once set, the index cannot be changed.
+     * @param index - The index to set.
+     * @returns `Success` with the index if successful, `Failure` with an error message otherwise.
+     */
+    setIndex(index: QualifierIndex): Result<QualifierIndex>;
+}
+
+/**
+ * Converter which choose a qualifier by name or number from a
+ * supplied {@link Qualifiers.Convert.IQualifierConvertContext | conversion context}.
+ * @public
+ */
+declare const qualifier: Converter<Qualifier, IQualifierConvertContext>;
+
+/**
+ * Collects {@link Qualifiers.Qualifier | Qualifiers} from {@link Qualifiers.IQualifierDecl | declarations},
+ * with strongly-typed ({@link QualifierName | QualifierName} and {@link QualifierIndex | QualifierIndex}) key
+ * and index.
+ * @public
+ */
+declare class QualifierCollector extends ValidatingConvertingCollector<Qualifier, IQualifierDecl> implements IReadOnlyQualifierCollector {
+    /**
+     * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} that this collector uses.
+     */
+    qualifierTypes: ReadOnlyQualifierTypeCollector;
+    /**
+     * Constructor for a {@link Qualifiers.QualifierCollector | QualifierCollector} object.
+     * @param params - Parameters for creating the collector.
+     * @public
+     */
+    protected constructor(params: IQualifierCollectorCreateParams);
+    /**
+     * Creates a new {@link Qualifiers.QualifierCollector | QualifierCollector} object.
+     * @param params - {@link Qualifiers.IQualifierCollectorCreateParams | Parameters} for creating a new {@link Qualifiers.QualifierCollector | QualifierCollector}.
+     * @returns `Success` with the new collector if successful, or `Failure` if not.
+     */
+    static create(params: IQualifierCollectorCreateParams): Result<QualifierCollector>;
+    /**
+     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.getByNameOrToken}
+     */
+    getByNameOrToken(nameOrToken: string): Result<Qualifier>;
+    /**
+     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}
+     */
+    hasNameOrToken(nameOrToken: string): boolean;
+    /**
+     * Gets a read-only view of this collector.
+     * @returns A read-only view of this collector.
+     */
+    toReadOnly(): IReadOnlyQualifierCollector;
+    /**
+     * Factory method for creating a {@link Qualifiers.Qualifier | Qualifier} from a {@link Qualifiers.IQualifierDecl | declaration}.
+     * @param __key - The key for the qualifier.
+     * @param index - The index of the qualifier.
+     * @param decl - The {@link Qualifiers.IQualifierDecl | declaration} for the qualifier.
+     * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful, or `Failure` if not.
+     * @public
+     */
+    protected _qualifierFactory(__key: QualifierName, index: number, decl: IQualifierDecl): Result<Qualifier>;
+}
+
+/**
+ * Branded type for a validated qualifier condition value - i.e. a value
+ * that has been determined to be valid for use in a condition attached
+ * to some resource.
+ *
+ * @example
+ * For a language qualifier type, it is likely that a single language
+ * tag can be used for either a condition or a context value. However,
+ * a list of languages would likely only be valid as a context value.
+ * @public
+ */
+export declare type QualifierConditionValue = Brand<string, 'QualifierConditionValue'>;
+
+/**
+ * Branded type for a validated qualifier context value - i.e. a value
+ * that has been determined to be valid for use in some runtime context.
+ * @example
+ * For a language qualifier type, it is likely that a single language
+ * tag can be used for either a condition or a context value. However,
+ * a list of languages would likely only be valid as a context value.
+ * @public
+ */
+export declare type QualifierContextValue = Brand<string, 'QualifierContextValue'>;
+
+/**
+ * Converter for a {@link Qualifiers.IQualifierDecl | qualifier declaration}.
+ * @public
+ */
+declare const qualifierDecl: ObjectConverter<IQualifierDecl, unknown>;
+
+/**
+ * Branded number representing a validated qualifier index.
+ * @public
+ */
+export declare type QualifierIndex = Brand<number, 'QualifierIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierIndex | QualifierIndex}.
+ * @public
+ */
+declare const qualifierIndex: Converter<QualifierIndex, unknown>;
+
+/**
+ * Branded number representing a score in the range 0.0 (no match) .. 1.0 (perfect match)
+ * which results from evaluating some condition.
+ * @public
+ */
+export declare type QualifierMatchScore = Brand<number, 'QualifierMatchScore'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierConditionValue | QualifierConditionValue}.
+ * @public
+ */
+declare const qualifierMatchScore: Converter<QualifierMatchScore, unknown>;
+
+/**
+ * Branded string representing a validated qualifier name.
+ * @public
+ */
+export declare type QualifierName = Brand<string, 'QualifierName'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierName | QualifierName}.
+ * @public
+ */
+declare const qualifierName: Converter<QualifierName, unknown>;
+
+declare namespace Qualifiers {
+    export {
+        Convert_5 as Convert,
+        Qualifier,
+        IQualifierDecl,
+        IValidatedQualifierDecl,
+        IReadOnlyQualifierCollector,
+        IQualifierCollectorCreateParams,
+        QualifierCollector
+    }
+}
+export { Qualifiers }
+
+/**
+ * Abstract base class for qualifier types. Provides default implementations for
+ * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
+ * @public
+ */
+declare abstract class QualifierType implements IQualifierType {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.name}
+     */
+    readonly name: QualifierTypeName;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.key}
+     */
+    get key(): QualifierTypeName;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.index}
+     */
+    get index(): QualifierTypeIndex | undefined;
+    protected readonly _collectible: Collections.Collectible<QualifierTypeName, QualifierTypeIndex>;
+    /**
+     * Flag indicating whether this qualifier type allows a list of values in a context.
+     * @public
+     */
+    readonly allowContextList: boolean;
+    /**
+     * Constructor for use by derived classes.
+     * @param name - The name of the qualifier type.
+     * @param allowContextList - Flag indicating whether this qualifier type allows a
+     * comma-separated list of runtime values in the context. Defaults to `false`.
+     */
+    protected constructor({ name, index, allowContextList }: IQualifierTypeCreateParams);
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
+     */
+    abstract isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isValidContextValue}
+     */
+    isValidContextValue(value: string): value is QualifierContextValue;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateCondition}
+     */
+    validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateContextValue}
+     */
+    validateContextValue(value: string): Result<QualifierContextValue>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.matches}
+     */
+    matches(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
+     */
+    setIndex(index: number): Result<QualifierTypeIndex>;
+    /**
+     * {@inheritdoc Validate.isValidQualifierTypeName}
+     */
+    static isValidName(name: string): name is QualifierTypeName;
+    /**
+     * {@inheritdoc Validate.isValidQualifierTypeIndex}
+     */
+    static isValidIndex(index: number): index is QualifierTypeIndex;
+    /**
+     * Compares two qualifier types by index.
+     * @param t1 - The first qualifier type to compare.
+     * @param t2 - The second qualifier type to compare.
+     * @returns a number indicating the relative order of the two qualifier types.
+     */
+    static compare(t1: QualifierType, t2: QualifierType): number;
+    /**
+     * Matches a single condition value against a single context value.
+     * @param condition - The {@link QualifierConditionValue | condition value} to match.
+     * @param context - The {@link QualifierContextValue | context value} to match.
+     * @param operator - The {@link ConditionOperator | operator} to use in the match.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
+     * matches the context value.
+     * @public
+     */
+    protected abstract _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * Matches a single condition value against a list of context values.
+     * @param condition - The {@link QualifierConditionValue | condition value} to match.
+     * @param context - The comma-separated list of {@link QualifierContextValue | context values} to match.
+     * @param operator - The {@link ConditionOperator | operator} to use in the match.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
+     * matches the context value.
+     * @public
+     */
+    protected _matchList(condition: QualifierConditionValue, context: QualifierContextValue[], operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * Splits a comma-separated {@link QualifierContextValue | context value} into an array of
+     * individual values.
+     * @param value - The value to split.
+     * @returns an array of individual context values.
+     * @public
+     */
+    protected static _splitContext(value: QualifierContextValue): QualifierContextValue[];
+}
+
+/**
+ * Converter for {@link QualifierTypes.QualifierType | QualifierType} objects,
+ * retrieves a {@link QualifierTypes.QualifierType | QualifierType} by name or
+ * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.
+ * @public
+ */
+declare const qualifierType: Converter<QualifierType, IQualifierTypeConvertContext>;
+
+/**
+ * Collector for {@link QualifierTypes.QualifierType | QualifierType} objects.
+ * @public
+ */
+declare class QualifierTypeCollector extends ValidatingConvertingCollector<QualifierType, QualifierType> {
+    /**
+     * Constructor for a {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} object.
+     * @param params - Optional {@link QualifierTypes.IQualifierTypeCollectorCreateParams | parameters} used to construct the collector.
+     */
+    protected constructor({ qualifierTypes }: IQualifierTypeCollectorCreateParams);
+    /**
+     * Creates a new {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} object.
+     * @param params - Optional {@link QualifierTypes.IQualifierTypeCollectorCreateParams | parameters}
+     * used to create the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` if not.
+     */
+    static create(params?: IQualifierTypeCollectorCreateParams): Result<QualifierTypeCollector>;
+    protected static _qualifierTypeFactory(key: QualifierTypeName, index: number, value: QualifierType): Result<QualifierType>;
+    protected static _toQualifierType(from: unknown): Result<QualifierType>;
+}
+
+/**
+ * Branded number representing a validated qualifier type index.
+ * @public
+ */
+export declare type QualifierTypeIndex = Brand<number, 'QualifierTypeIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierTypeIndex | QualifierTypeIndex}.
+ * @public
+ */
+declare const qualifierTypeIndex: Converter<QualifierTypeIndex, unknown>;
+
+/**
+ * Branded string representing a validated qualifier type name.
+ * @public
+ */
+export declare type QualifierTypeName = Brand<string, 'QualifierTypeName'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierTypeName | QualifierTypeName}.
+ * @public
+ */
+declare const qualifierTypeName: Converter<QualifierTypeName, unknown>;
+
+declare namespace QualifierTypes {
+    export {
+        Convert_4 as Convert,
+        IQualifierType,
+        IQualifierTypeCreateParams,
+        QualifierType,
+        ILanguageQualifierTypeCreateParams,
+        LanguageQualifierType,
+        ILiteralQualifierTypeCreateParams,
+        LiteralQualifierType,
+        ITerritoryQualifierTypeCreateParams,
+        TerritoryQualifierType,
+        IQualifierTypeCollectorCreateParams,
+        QualifierTypeCollector,
+        ReadOnlyQualifierTypeCollector
+    }
+}
+export { QualifierTypes }
+
+/**
+ * A read-only {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+ * @public
+ */
+declare type ReadOnlyAbstractDecisionCollector = Collections.IReadOnlyValidatingCollector<AbstractDecision>;
+
+/**
+ * Type alias for a read-only {@link Conditions.ConditionCollector | ConditionCollector}.
+ * @public
+ */
+declare type ReadOnlyConditionCollector = Collections.IReadOnlyValidatingCollector<Condition>;
+
+/**
+ * A read-only {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+ * @public
+ */
+declare type ReadOnlyConditionSetCollector = Collections.IReadOnlyValidatingCollector<ConditionSet>;
+
+/**
+ * Interface exposing non-mutating members of a {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector}.
+ * @public
+ */
+declare type ReadOnlyQualifierTypeCollector = Collections.IReadOnlyValidatingCollector<QualifierType>;
+
+/**
+ * A read-only version of {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector}.
+ * @public
+ */
+declare type ReadOnlyResourceTypeCollector = Collections.IReadOnlyValidatingCollector<ResourceType>;
+
+declare namespace RegularExpressions {
+    export {
+        identifier,
+        segmentedIdentifier,
+        identifierList,
+        conditionKey_2 as conditionKey,
+        conditionToken_2 as conditionToken,
+        conditionSetHash_2 as conditionSetHash,
+        decisionKey_2 as decisionKey,
+        territoryCode
+    }
+}
+
+/**
+ * Represents a single logical resource, with a unique id and a set of possible
+ * candidate instances.
+ * @public
+ */
+declare class Resource {
+    /**
+     * The unique {@link ResourceId | id} of the resource.
+     */
+    readonly id: ResourceId;
+    /**
+     * The {@link ResourceTypes.ResourceType | type} of the resource.
+     */
+    readonly resourceType: ResourceType;
+    /**
+     * The array of {@link Resources.ResourceCandidate | candidates} for the resource.
+     */
+    readonly candidates: ReadonlyArray<ResourceCandidate>;
+    /**
+     * Constructor for a {@link Resources.Resource | Resource} object.
+     * @param params - {@link Resources.IResourceCreateParams | Parameters} used to create the resource.
+     * @public
+     */
+    protected constructor(params: IResourceCreateParams);
+    /**
+     * Creates a new {@link Resources.Resource | Resource} object.
+     * @param params - {@link Resources.IResourceCreateParams | Parameters} used to create the resource.
+     * @returns `Success` with the new {@link Resources.Resource | Resource} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IResourceCreateParams): Result<Resource>;
+    /**
+     * Validates that all candidates have the same id as the resource.
+     * @param resourceId - The expected id of the resource.
+     * @param candidates - The array of candidates to validate.
+     * @returns `Success` with the resource id if all candidates have the same id,
+     * `Failure` with an error message otherwise.
+     * @internal
+     */
+    private static _validateCandidateResourceIds;
+    /**
+     * Validates and normalizes an array of {@link Resources.ResourceCandidate | candidates}. Fails if there
+     * are multiple candidates for the same set of conditions.
+     * @param candidates - The array of candidates to validate.
+     * @returns `Success` with the validated and sorted array of candidates if successful,
+     * `Failure` with an error message otherwise.
+     * @internal
+     */
+    private static _validateAndNormalizeCandidates;
+}
+
+/**
+ * Represents a builder for a single logical {@link Resources.Resource | resource}.  Collects candidates
+ * with a common resource ID, validates them against each other and builds a {@link Resources.Resource | resource}
+ * object once all candidates are collected.
+ * @public
+ */
+declare class ResourceBuilder {
+    /**
+     * The unique {@link ResourceId | id} of the resource being built.
+     */
+    readonly id: ResourceId;
+    /**
+     * Supplied or inferred {@link ResourceTypes.ResourceType | type} of the resource being built.
+     * If no type is supplied, the type will be inferred from the candidates - at least one candidate must
+     * define resource type and all candidates must be of the same type.
+     */
+    get resourceType(): ResourceType | undefined;
+    /**
+     * Array of {@link Resources.ResourceCandidate | candidates} for the resource being built.
+     */
+    get candidates(): ReadonlyArray<ResourceCandidate>;
+    /**
+     * The supplied or inferred {@link ResourceTypes.ResourceType | type} of the resource
+     * being built.
+     */
+    protected _resourceType: ResourceType | undefined;
+    /**
+     * Map of {@link Resources.ResourceCandidate | candidates} for the resource being built.
+     */
+    protected _candidates: ResultMap<string, ResourceCandidate>;
+    /**
+     * Map of all known {@link ResourceTypes.ResourceType | resource types}.
+     */
+    protected _resourceTypes: ReadOnlyResourceTypeCollector;
+    /**
+     * Common collector for {@link Conditions.ConditionSet | condition sets}.
+     */
+    protected _conditionSets: ConditionSetCollector;
+    /**
+     * Constructor for a {@link Resources.ResourceBuilder | ResourceBuilder} object.
+     * @param params - Parameters to construct the new {@link Resources.ResourceBuilder | ResourceBuilder}.
+     */
+    protected constructor(params: IResourceBuilderCreateParams);
+    /**
+     * Creates a new {@link Resources.ResourceBuilder | ResourceBuilder} object.
+     * @param params - Parameters to create a new {@link Resources.ResourceBuilder | ResourceBuilder}.
+     * @returns `Success` with the new {@link Resources.ResourceBuilder | ResourceBuilder} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IResourceBuilderCreateParams): Result<ResourceBuilder>;
+    /**
+     * Given a {@link ResourceJson.Json.IChildResourceCandidateDecl | child resource candidate declaration}, creates and adds a
+     * {@link Resources.ResourceCandidate | candidate} to the resource being built.
+     * @param candidate - The {@link ResourceJson.Json.IChildResourceCandidateDecl | IChildResourceCandidateDecl} to add to the
+     * resource being built.
+     * @returns `Success` with the added {@link Resources.ResourceCandidate | candidate} if successful,
+     * or `Failure` with an error message if not.
+     */
+    addChildCandidate(childDecl: ResourceJson.Json.IChildResourceCandidateDecl): DetailedResult<ResourceCandidate, ResourceBuilderResultDetail>;
+    /**
+     * Given a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration}, creates and adds a
+     * {@link Resources.ResourceCandidate | candidate} to the resource being built.
+     * @param candidate - The {@link ResourceJson.Json.ILooseResourceCandidateDecl | IResourceCandidateDecl} to add to the
+     * resource being built.
+     * @returns `Success` with the added {@link Resources.ResourceCandidate | candidate} if successful,
+     * or `Failure` with an error message if not. Fails with error detail 'type-mismatch' if the candidate
+     * specifies a different resource type than previously added candidates, or with 'exists' if a candidate
+     * already exists with the same conditions but different values.  Succeeds with 'exists' and returns the
+     * existing candidate if the candidate to be added is identical to an existing candidate.
+     */
+    addLooseCandidate(decl: ResourceJson.Json.ILooseResourceCandidateDecl): DetailedResult<ResourceCandidate, ResourceBuilderResultDetail>;
+    /**
+     * Sets the resource type for the resource being built.  Fails if a resource type has already been set
+     * and it does not match the new resource type.
+     * @param resourceTypeName - The name of the resource type to set.
+     * @returns `Success` with the updated {@link Resources.ResourceBuilder | ResourceBuilder} object if successful,
+     * or `Failure` with an error message if not.
+     */
+    setResourceType(resourceTypeName: string): Result<ResourceBuilder>;
+    /**
+     * Builds the {@link Resources.Resource | resource} object from this builder.
+     * @returns `Success` with the new {@link Resources.Resource | Resource} object if successful,
+     * or `Failure` with an error message if not. Fails if no candidates have been added
+     * or if the resource type is not defined.
+     */
+    build(): Result<Resource>;
+}
+
+/**
+ * Possible result details returned by the resource builder
+ * {@link Resources.ResourceBuilder.addLooseCandidate | addLooseCandidate} method.
+ * @public
+ */
+declare type ResourceBuilderResultDetail = Collections.ResultMapResultDetail | 'id-mismatch' | 'type-mismatch';
+
+/**
+ * A {@link Resources.ResourceCandidate | resource candidate} represents a single possible
+ * instance value for some resource, with the conditions under which it applies
+ * and instructions on how to merge it with other instances.
+ * @public
+ */
+declare class ResourceCandidate {
+    /**
+     * The unique identifier of the resource for which this candidate
+     * is a possible instance.
+     */
+    readonly id: ResourceId;
+    /**
+     * The JSON representation of the instance data to be applied.
+     */
+    readonly json: JsonValue;
+    /**
+     * The conditions under which this candidate applies.
+     */
+    readonly conditions: ConditionSet;
+    /**
+     * True if this candidate is a partial instance.
+     */
+    readonly isPartial: boolean;
+    /**
+     * The method to use when merging this candidate with other instances.
+     */
+    readonly mergeMethod: ResourceValueMergeMethod;
+    /**
+     * The {@link ResourceTypes.ResourceType | resource type} for the resource to which
+     * this candidate belongs.
+     */
+    readonly resourceType: ResourceType | undefined;
+    /**
+     * Constructor for a {@link Resources.ResourceCandidate | ResourceCandidate} object.
+     * @param params - Parameters to create a new {@link Resources.ResourceCandidate | ResourceCandidate}.
+     * @public
+     */
+    protected constructor(params: IResourceCandidateCreateParams);
+    /**
+     * Creates a new {@link Resources.ResourceCandidate | ResourceCandidate} object.
+     * @param params - Parameters to create a new {@link Resources.ResourceCandidate | ResourceCandidate}.
+     * @returns `Success` with the new {@link Resources.ResourceCandidate | ResourceCandidate} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IResourceCandidateCreateParams): Result<ResourceCandidate>;
+    /**
+     * Extracts the {@link ResourceTypes.ResourceType | resource type} from a list of {@link Resources.ResourceCandidate | resource candidates},
+     * if present.
+     * @param candidates - The list of candidates from which to extract the resource type.
+     * @returns `Success` with the resource type if successful, `Success` with `undefined` if none of the candidates
+     * specify a resource tap, and `Failure` with an error message if clients specify conflicting resource types.
+     * @public
+     */
+    static validateResourceTypes(candidates: ReadonlyArray<ResourceCandidate>, expectedType?: ResourceType): Result<ResourceType | undefined>;
+    /**
+     * Compares two {@link Resources.ResourceCandidate | ResourceCandidates} for sorting purposes.
+     * @param rc1 - The first candidate to compare.
+     * @param rc2 - The second candidate to compare.
+     * @returns A negative number if `rc1` should come before `rc2`, a positive number if `rc2` should come before `rc1`,
+     * or zero if they are equivalent.
+     * @public
+     */
+    static compare(rc1: ResourceCandidate, rc2: ResourceCandidate): number;
+    /**
+     * Compares two {@link Resources.ResourceCandidate | ResourceCandidates} for equality.
+     * @param rc1 - The first candidate to compare.
+     * @param rc2 - The second candidate to compare.
+     * @returns `true` if the candidates are equal, `false` otherwise.
+     * @public
+     */
+    static equal(rc1: ResourceCandidate, rc2: ResourceCandidate): boolean;
+    /**
+     * Validates declared conditions and merges them with parent conditions.
+     * @param conditionSets - The {@link Conditions.ConditionSetCollector | condition set collector}
+     * to use for this candidate.
+     * @param declared - The declared conditions for the candidate.
+     * @param parent - The parent conditions to merge with the declared conditions.
+     * @returns `Success` with the merged conditions if successful, `Failure` otherwise.
+     * @internal
+     */
+    private static _mergeConditions;
+}
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.IResourceCollectionDecl | resource collection declaration}.
+ * @public
+ */
+declare const resourceCollectionDecl: Converter<Normalized.IResourceCollectionDecl>;
+
+/**
+ * Class that extracts resources and candidates from a
+ * {@link ResourceJson.Json.IResourceCollectionDecl | resource collection declaration}.
+ * @public
+ */
+declare class ResourceDeclCollection implements IResourceDeclContainer {
+    /**
+     * The {@link ResourceJson.Normalized.IResourceCollectionDecl | resource collection declaration}
+     * being processed.
+     */
+    readonly collection: Normalized.IResourceCollectionDecl;
+    protected _resources: Normalized.ILooseResourceDecl[];
+    protected _candidates: Normalized.ILooseResourceCandidateDecl[];
+    protected constructor(collection: Normalized.IResourceCollectionDecl);
+    /**
+     * Creates a new {@link ResourceJson.ResourceDeclCollection | ResourceDeclCollection} from an
+     * untyped {@link ResourceJson.Json.IResourceCollectionDecl | resource collection declaration}.
+     * @param from - The JSON object to convert.
+     * @returns `Success` with the new collection if the JSON object is valid, otherwise `Failure`.
+     */
+    static create(from: unknown): Result<ResourceDeclCollection>;
+    /**
+     * Gets the loose resources extracted from the collection.
+     * @returns The {@link ResourceJson.Normalized.ILooseResourceDecl | loose resource declarations}
+     * extracted from the collection.
+     */
+    getLooseResources(): ReadonlyArray<Normalized.ILooseResourceDecl>;
+    /**
+     * Gets the loose candidates extracted from the collection.
+     * @returns The {@link ResourceJson.Normalized.ILooseResourceCandidateDecl | loose resource candidate declarations}
+     * extracted from the collection.
+     */
+    getLooseCandidates(): ReadonlyArray<Normalized.ILooseResourceCandidateDecl>;
+    private _extract;
+}
+
+/**
+ * Class that extracts resources and candidates from a
+ * {@link ResourceJson.Json.IResourceTreeRootDecl | resource tree root}.
+ * @public
+ */
+declare class ResourceDeclTree implements IResourceDeclContainer {
+    /**
+     * The {@link ResourceJson.Normalized.IResourceTreeRootDecl | resource tree root declaration}
+     * being processed.
+     */
+    readonly tree: Normalized.IResourceTreeRootDecl;
+    protected _resources: Normalized.ILooseResourceDecl[];
+    protected _candidates: Normalized.ILooseResourceCandidateDecl[];
+    protected constructor(tree: Normalized.IResourceTreeRootDecl);
+    /**
+     * Creates a new {@link ResourceJson.ResourceDeclTree | ResourceDeclTree} from an
+     * untyped {@link ResourceJson.Json.IResourceTreeRootDecl | resource tree root declaration}.
+     * @param from - The JSON object to convert.
+     * @returns `Success` with the new tree if the JSON object is valid, otherwise `Failure`.
+     */
+    static create(from: unknown): Result<ResourceDeclTree>;
+    /**
+     * Gets the loose resources extracted from the collection.
+     * @returns The {@link ResourceJson.Normalized.ILooseResourceDecl | loose resource declarations}
+     * extracted from the collection.
+     */
+    getLooseResources(): ReadonlyArray<Normalized.ILooseResourceDecl>;
+    /**
+     * Gets the loose candidates extracted from the collection.
+     * @returns The {@link ResourceJson.Normalized.ILooseResourceCandidateDecl | loose resource candidate declarations}
+     * extracted from the collection.
+     */
+    getLooseCandidates(): ReadonlyArray<Normalized.ILooseResourceCandidateDecl>;
+    private _extract;
+}
+
+/**
+ * Branded string representing a validated resource id.  A resource ID
+ * is a dot-separated sequence of resource names.
+ * @public
+ */
+export declare type ResourceId = Brand<string, 'ResourceId'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ResourceId | ResourceId}.
+ * @public
+ */
+declare const resourceId: Converter<ResourceId, unknown>;
+
+/**
+ * Branded number representing a validated resource index.
+ * @public
+ */
+export declare type ResourceIndex = Brand<number, 'ResourceIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ResourceIndex | ResourceIndex}.
+ * @public
+ */
+declare const resourceIndex: Converter<ResourceIndex, unknown>;
+
+declare namespace ResourceJson {
+    export {
+        Convert_3 as Convert,
+        Helpers_2 as Helpers,
+        Json,
+        Normalized,
+        IResourceDeclContainer,
+        ResourceDeclCollection,
+        ResourceDeclTree
+    }
+}
+export { ResourceJson }
+
+/**
+ * Represents a manager for a collection of {@link Resources.Resource | resources}.  Collects
+ * {@link Resources.ResourceCandidate | candidates} for each resource into a
+ * {@link Resources.ResourceBuilder | ResourceBuilder} per resource, validates them against each other,
+ * and builds a collection of {@link Resources.Resource | resources} once all candidates are collected.
+ * @public
+ */
+declare class ResourceManager {
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    readonly resourceTypes: ReadOnlyResourceTypeCollector;
+    protected readonly _conditions: ConditionCollector;
+    protected readonly _conditionSets: ConditionSetCollector;
+    protected readonly _decisions: AbstractDecisionCollector;
+    protected readonly _resources: ValidatingResultMap<ResourceId, ResourceBuilder>;
+    protected readonly _builtResources: ValidatingResultMap<ResourceId, Resource>;
+    protected _built: boolean;
+    /**
+     * A {@link Conditions.ConditionCollector | ConditionCollector} which
+     * contains the {@link Conditions.Condition | conditions} used so far by
+     * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
+     */
+    get conditions(): ReadOnlyConditionCollector;
+    /**
+     * A {@link Conditions.ConditionSetCollector | ConditionSetCollector} which
+     * contains the {@link Conditions.ConditionSet | condition sets} used so far by
+     * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
+     */
+    get conditionSets(): ReadOnlyConditionSetCollector;
+    /**
+     * A {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector} which
+     * contains the {@link Decisions.Decision | abstract decisions} used so far by
+     * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
+     */
+    get decisions(): ReadOnlyAbstractDecisionCollector;
+    /**
+     * A read-only map of {@link Resources.ResourceBuilder | resource builders} used by the manager.
+     */
+    get resources(): Collections.IReadOnlyValidatingResultMap<ResourceId, ResourceBuilder>;
+    /**
+     * The number of {@link Resources.Resource | resources} contained by the manager.
+     */
+    get size(): number;
+    /**
+     * Constructor for a {@link Resources.ResourceManager | ResourceManager} object.
+     * @param params - Parameters to create a new {@link Resources.ResourceManager | ResourceManager}.
+     * @public
+     */
+    protected constructor(params: IResourceManagerCreateParams);
+    /**
+     * Creates a new {@link Resources.ResourceManager | ResourceManager} object.
+     * @param params - Parameters to create a new {@link Resources.ResourceManager | ResourceManager}.
+     * @returns `Success` with the new {@link Resources.ResourceManager | ResourceManager} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IResourceManagerCreateParams): Result<ResourceManager>;
+    /**
+     * Given a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration}, builds and adds
+     * a {@link Resources.ResourceCandidate | candidate} to the manager.
+     * @param candidate - The {@link Resources.ResourceCandidate | candidate} to add.
+     * @returns `Success` with the candidate if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    addLooseCandidate(decl: ResourceJson.Json.ILooseResourceCandidateDecl): DetailedResult<ResourceCandidate, ResourceManagerResultDetail>;
+    addResource(decl: ResourceJson.Json.ILooseResourceDecl): DetailedResult<ResourceBuilder, ResourceManagerResultDetail>;
+    /**
+     * Gets an individual {@link Resources.Resource | built resource} from the manager.
+     * @param id - The {@link ResourceId | id} of the resource to get.
+     * @returns `Success` with the resource if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    getBuiltResource(id: string): Result<Resource>;
+    /**
+     * Builds the {@link Resources.Resource | resources} from the collected {@link Resources.ResourceCandidate | candidates}.
+     * @returns `Success` with a read-only map of {@link Resources.Resource | resources} if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    build(): Result<Collections.IReadOnlyValidatingResultMap<ResourceId, Resource>>;
+}
+
+/**
+ * Error details that can be returned by a {@link Resources.ResourceManager | ResourceManager}.
+ * @public
+ */
+declare type ResourceManagerResultDetail = Collections.ResultMapResultDetail | ResourceBuilderResultDetail;
+
+/**
+ * Branded string representing a validated resource name.
+ * @public
+ */
+export declare type ResourceName = Brand<string, 'ResourceName'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ResourceName | ResourceName}.
+ * @public
+ */
+declare const resourceName: Converter<ResourceName, unknown>;
+
+declare namespace Resources {
+    export {
+        IResourceCandidateCreateParams,
+        ResourceCandidate,
+        IResourceCreateParams,
+        Resource,
+        IResourceBuilderCreateParams,
+        ResourceBuilderResultDetail,
+        ResourceBuilder,
+        IResourceManagerCreateParams,
+        ResourceManagerResultDetail,
+        ResourceManager
+    }
+}
+export { Resources }
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.IResourceTreeChildNodeDecl | resource tree child node declaration}.
+ * @public
+ */
+declare const resourceTreeChildNodeDecl: Converter<Normalized.IResourceTreeChildNodeDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.IResourceTreeRootDecl | resource tree root declaration}.
+ * @public
+ */
+declare const resourceTreeRootDecl: Converter<Normalized.IResourceTreeRootDecl>;
+
+/**
+ * Abstract base class for resource types which are responsible for
+ * validating and converting JSON values into the appropriate strongly-typed
+ * resource value.
+ * @public
+ */
+declare abstract class ResourceType<T = unknown> implements ICollectible<ResourceTypeName, ResourceTypeIndex> {
+    private _collectible;
+    /**
+     * The key for this resource type.
+     */
+    get key(): ResourceTypeName;
+    /**
+     * The index for this resource type.
+     */
+    get index(): ResourceTypeIndex | undefined;
+    protected constructor(key: ResourceTypeName, index?: number);
+    /**
+     * Validates a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
+     * a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - `true` indicates that the value is expected to be incomplete.
+     * @param mergeMethod - The method to use when merging with previously resolved values.
+     * @returns `Success` with the strongly-typed resource value if the JSON and merge
+     * method are valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validateDeclaration(json: JsonValue, isPartial: true, mergeMethod?: ResourceValueMergeMethod): Result<Partial<T>>;
+    /**
+     * Validates a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
+     * a complete resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - `false` indicates that the value is expected to be complete.
+     * @param mergeMethod - The method to use when merging with previously resolved values.
+     * @returns `Success` with the strongly-typed resource value if the JSON and merge method
+     * are valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validateDeclaration(json: JsonValue, isPartial: false, mergeMethod?: ResourceValueMergeMethod): Result<T>;
+    /**
+     * Validates a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
+     * a resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - Indicates whether the value is expected to be incomplete.
+     * @param mergeMethod - The method to use when merging with previously resolved values.
+     * @returns `Success` with the strongly-typed resource value if the JSON and merge method
+     * are valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validateDeclaration(json: JsonValue, isPartial: boolean, mergeMethod?: ResourceValueMergeMethod): Result<T | Partial<T>>;
+    abstract validateDeclaration(json: JsonValue, isPartial: boolean, mergeMethod?: ResourceValueMergeMethod): Result<T | Partial<T>>;
+    /**
+     * Validates a JSON value for use as a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - `true` indicates that the value is expected to be partial.
+     * @returns `Success` with the strongly-typed partial resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validate(json: JsonValue, isPartial: true): Result<T>;
+    /**
+     * Validates a JSON value for use as a complete resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - `false` indicates that the value is expected to be complete.
+     * @returns `Success` with the strongly-typed resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validate(json: JsonValue, isPartial: false): Result<Partial<T>>;
+    /**
+     * Validates a JSON value for use as a full or partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param isPartial - Indicates whether the value is expected to be partial.
+     * @returns `Success` with the strongly-typed full or partial resource value if
+     * the JSON is valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    abstract validate(json: JsonValue, isPartial: boolean): Result<T | Partial<T>>;
+    /**
+     * Sets the index for this resource type.  Once set, the index cannot be changed.
+     */
+    setIndex(index: number): Result<ResourceTypeIndex>;
+}
+
+/**
+ * Map {@link ResourceTypeName | resource type names} to {@link ResourceTypes.ResourceType | resource types}.
+ * @public
+ */
+declare class ResourceTypeCollector extends ValidatingCollector<ResourceType> {
+    protected constructor({ resourceTypes }: IResourceCollectorCreateParams);
+    /**
+     * Creates a new {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector}.
+     * @param params - Optional for creating the new collector.
+     * @returns `Success` with the new instance, or `Failure` with an error
+     * message if the collector could not be created.
+     */
+    static create(params?: IResourceCollectorCreateParams): Result<ResourceTypeCollector>;
+    protected _toResourceType(from: unknown): Result<ResourceType>;
+}
+
+/**
+ * Branded number representing a validated resource type index.
+ * @public
+ */
+export declare type ResourceTypeIndex = Brand<number, 'ResourceTypeIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ResourceTypeIndex | ResourceTypeIndex}.
+ * @public
+ */
+declare const resourceTypeIndex: Converter<ResourceTypeIndex, unknown>;
+
+/**
+ * Branded string representing a validated resource type name.
+ * @public
+ */
+export declare type ResourceTypeName = Brand<string, 'ResourceTypeName'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link ResourceTypeName | ResourceTypeName}.
+ * @public
+ */
+declare const resourceTypeName: Converter<ResourceTypeName, unknown>;
+
+declare namespace ResourceTypes {
+    export {
+        ResourceType,
+        IResourceCollectorCreateParams,
+        ResourceTypeCollector,
+        ReadOnlyResourceTypeCollector,
+        IJsonResourceTypeCreateParams,
+        JsonResourceType
+    }
+}
+export { ResourceTypes }
+
+/**
+ * Type representing the possible ways that a resource value can be merged into an existing resource.
+ * - 'augment' means that the new value should be merged into the existing value, with new properties added and existing properties updated.
+ * - 'delete' means that the existing values should be deleted.
+ * - 'replace' means that the new value should replace the existing value.
+ * @public
+ */
+export declare type ResourceValueMergeMethod = 'augment' | 'delete' | 'replace';
+
+/**
+ * `Converter` for a resource value merge method.
+ * @public
+ */
+declare const resourceValueMergeMethod: Converter<ResourceValueMergeMethod, ResourceValueMergeMethod[]>;
+
+/**
+ * @internal
+ */
+declare const segmentedIdentifier: RegExp;
+
+/**
+ * Splits a {@link ResourceId | resource id} into its component {@link ResourceName | resource names}.
+ *
+ * @param id - The ID to split.
+ * @returns `Success`with an array of {@link ResourceName | ResourceName} objects if the ID is valid, or
+ * `Failure` with an error message if not.
+ * @public
+ */
+declare function splitResourceId(id: string | undefined): Result<ResourceName[]>;
+
+/**
+ * @internal
+ */
+declare const territoryCode: RegExp;
+
+/**
+ * Qualifier type for territory values. Territories are two-letter ISO-3166-2
+ * Alpha-2 country codes.  Canonical territory codes are uppercase, but this
+ * implementation handles incorrect casing.
+ * @public
+ */
+declare class TerritoryQualifierType extends QualifierType {
+    /**
+     * Optional array enumerating allowed territories to further constrain the type.
+     */
+    readonly allowedTerritories?: ReadonlyArray<QualifierConditionValue>;
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
+     * @public
+     */
+    protected constructor({ allowedTerritories, allowContextList, name, index }: ITerritoryQualifierTypeCreateParams);
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
+     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters} to use
+     * when creating the instance.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} if successful,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(params?: ITerritoryQualifierTypeCreateParams): Result<TerritoryQualifierType>;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     */
+    protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue): QualifierMatchScore;
+    /**
+     * Determines whether a value is a valid condition value for a territory qualifier.
+     * @param value - The value to validate.
+     * @returns `true` if the value is a valid condition value, `false` otherwise.
+     * @public
+     */
+    static isValidTerritoryConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Converts a string value to a territory condition value.
+     * @param value - The value to convert.
+     * @returns `Success` with the converted value if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static toTerritoryConditionValue(value: string): Result<QualifierConditionValue>;
+}
+
+/**
+ * Converts a number to a {@link ConditionIndex} if it is a valid condition index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link ConditionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionIndex(index: number): Result<ConditionIndex>;
+
+/**
+ * Converts a string to a {@link ConditionKey} if it is a valid condition key.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionKey} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionKey(key: string): Result<ConditionKey>;
+
+/**
+ * Converts a string to a {@link ConditionOperator} if it is a valid condition operator.
+ * @param operator - the string to convert
+ * @returns `Success` with the converted {@link ConditionOperator} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionOperator(operator: string): Result<ConditionOperator>;
+
+/**
+ * Converts a number to a {@link ConditionPriority} if it is a valid priority.
+ * @param priority - the number to convert
+ * @returns `Success` with the converted {@link ConditionPriority} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionPriority(priority: number): Result<ConditionPriority>;
+
+/**
+ * Converts a string to a {@link ConditionSetHash} if it is a valid condition set hash.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetHash} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionSetHash(hash: string): Result<ConditionSetHash>;
+
+/**
+ * Converts a number to a {@link ConditionSetIndex} if it is a valid condition set index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link ConditionSetIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionSetIndex(index: number): Result<ConditionSetIndex>;
+
+/**
+ * Converts a string to a {@link ConditionSetKey} if it is a valid condition set key.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetKey} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionSetKey(key: string): Result<ConditionSetKey>;
+
+/**
+ * Converts a string to a {@link ConditionSetToken} if it is a valid condition set token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionSetToken(token: string): Result<ConditionSetToken>;
+
+/**
+ * Converts a string to a {@link ConditionToken} if it is a valid condition token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ConditionToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toConditionToken(token: string): Result<ConditionToken>;
+
+/**
+ * Converts a number to a {@link DecisionIndex} if it is a valid decision index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link DecisionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toDecisionIndex(index: number): Result<DecisionIndex>;
+
+/**
+ * Converts a number to a {@link DecisionIndex} if it is a valid decision index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link DecisionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toDecisionKey(key: string): Result<DecisionKey>;
+
+/**
+ * Converts an optional string to an optional {@link ResourceId | resource ID}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted ID if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toOptionalResourceId(id?: string): Result<ResourceId | undefined>;
+
+/**
+ * Converts a number to a {@link QualifierIndex} if it is a valid qualifier index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link QualifierIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toQualifierIndex(index: number): Result<QualifierIndex>;
+
+/**
+ * Converts a number to a {@link QualifierMatchScore | match score} if it is a valid score.
+ * @param value - The number to convert.
+ * @returns `Success` with the converted score if successful, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toQualifierMatchScore(value: number): Result<QualifierMatchScore>;
+
+/**
+ * Converts a string to a {@link QualifierName} if it is a valid qualifier name.
+ * @param name - the string to convert
+ * @returns `Success` with the converted {@link QualifierName} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toQualifierName(name: string): Result<QualifierName>;
+
+/**
+ * Converts a number to a {@link QualifierTypeIndex} if it is a valid qualifier type index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link QualifierTypeIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toQualifierTypeIndex(index: number): Result<QualifierTypeIndex>;
+
+/**
+ * Converts a string to a {@link QualifierTypeName} if it is a valid qualifier type name.
+ * @param name - the string to convert
+ * @returns `Success` with the converted {@link QualifierTypeName} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toQualifierTypeName(name: string): Result<QualifierTypeName>;
+
+/**
+ * Converts a string to a {@link ResourceId | resource ID}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted ID if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toResourceId(id: string): Result<ResourceId>;
+
+/**
+ * Converts a number to a {@link ResourceIndex | resource index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toResourceIndex(index: number): Result<ResourceIndex>;
+
+/**
+ * Converts a string to a {@link ResourceName | resource name}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted name if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toResourceName(name: string): Result<ResourceName>;
+
+/**
+ * Converts a number to a {@link ResourceTypeIndex | resource type index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toResourceTypeIndex(index: number): Result<ResourceTypeIndex>;
+
+/**
+ * Converts a string to a {@link ResourceTypeName | resource type name}.
+ *
+ * @param name - The string to convert.
+ * @returns `Success` with the converted name if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toResourceTypeName(name: string): Result<ResourceTypeName>;
+
+declare namespace Validate {
+    export {
+        RegularExpressions,
+        isValidQualifierName,
+        isValidQualifierTypeName,
+        isValidConditionPriority,
+        isValidQualifierIndex,
+        isValidQualifierTypeIndex,
+        isValidQualifierMatchScore,
+        isValidConditionIndex,
+        isValidConditionOperator,
+        isValidConditionKey,
+        isValidConditionToken,
+        isValidConditionSetIndex,
+        isValidConditionSetKey,
+        isValidConditionSetToken,
+        isValidConditionSetHash,
+        isValidDecisionKey,
+        isValidDecisionIndex,
+        toQualifierName,
+        toQualifierIndex,
+        toQualifierTypeName,
+        toQualifierTypeIndex,
+        toQualifierMatchScore,
+        toConditionPriority,
+        toConditionIndex,
+        toConditionOperator,
+        toConditionKey,
+        toConditionToken,
+        toConditionSetIndex,
+        toConditionSetKey,
+        toConditionSetToken,
+        toConditionSetHash,
+        toDecisionKey,
+        toDecisionIndex,
+        isValidResourceName,
+        isValidResourceId,
+        isValidResourceIndex,
+        isValidResourceTypeName,
+        isValidResourceTypeIndex,
+        toResourceName,
+        toResourceId,
+        toOptionalResourceId,
+        toResourceIndex,
+        toResourceTypeName,
+        toResourceTypeIndex
+    }
+}
+export { Validate }
+
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+ * from a {@link Conditions.IConditionDecl | condition declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionDeclConvertContext | conversion context}.
+ * @public
+ */
+declare const validatedConditionDecl: Converter<IValidatedConditionDecl, IConditionDeclConvertContext>;
+
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionSetDecl | validated condition set declaration}
+ * from a {@link Conditions.IConditionSetDecl | condition set declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionSetDeclConvertContext | conversion context}.
+ * @public
+ */
+declare const validatedConditionSetDecl: Converter<IValidatedConditionSetDecl, IConditionSetDeclConvertContext>;
+
+/**
+ * Converter which constructs a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}
+ * from a {@link Qualifiers.IQualifierDecl | qualifier declaration}, instantiating qualifier types by name
+ * from a supplied {@link Qualifiers.Convert.IQualifierDeclConvertContext | conversion context}.
+ * @public
+ */
+declare const validatedQualifierDecl: Converter<IValidatedQualifierDecl, IQualifierDeclConvertContext>;
+
+export { }