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

package/src/packlets/qualifiers/qualifierDefaultValueToken.ts

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { mapResults, Result, fail, succeed } from '@fgv/ts-utils';
+import { Helpers as CommonHelpers, QualifierName, QualifierContextValue } from '../common';
+import {
+  IValidatedQualifierDefaultValueDecl,
+  IValidatedQualifierDefaultValuesDecl
+} from './qualifierDefaultValueDecls';
+import { IReadOnlyQualifierCollector } from './qualifierCollector';
+
+/**
+ * Helper class to parse and validate qualifier default value tokens.
+ * @public
+ */
+export class QualifierDefaultValueTokens {
+  /**
+   * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to validate
+   * qualifier names and values.
+   */
+  public readonly qualifiers: IReadOnlyQualifierCollector;
+
+  /**
+   * Constructs a new {@link Qualifiers.QualifierDefaultValueTokens | QualifierDefaultValueTokens } instance.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+   */
+  public constructor(qualifiers: IReadOnlyQualifierCollector) {
+    this.qualifiers = qualifiers;
+  }
+
+  /**
+   * Parses a {@link QualifierDefaultValueToken | qualifier default value token} string and validates the parts
+   * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.
+   * @param token - the token string to parse.
+   * @returns `Success` with the {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration}
+   * if successful, `Failure` with an error message if not.
+   */
+  public parseQualifierDefaultValueToken(token: string): Result<IValidatedQualifierDefaultValueDecl> {
+    return QualifierDefaultValueTokens.parseQualifierDefaultValueToken(token, this.qualifiers);
+  }
+
+  /**
+   * Parses a {@link QualifierDefaultValuesToken | qualifier default values token} string and validates the parts
+   * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.
+   * @param token - the token string to parse.
+   * @returns `Success` with the array of {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}
+   * if successful, `Failure` with an error message if not.
+   */
+  public parseQualifierDefaultValuesToken(token: string): Result<IValidatedQualifierDefaultValueDecl[]> {
+    return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, this.qualifiers);
+  }
+
+  /**
+   * Validates the {@link Helpers.IQualifierDefaultValueTokenParts | parts} of a {@link QualifierDefaultValueToken | qualifier default value token}.
+   * @param parts - the parts to validate
+   * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.
+   */
+  public validateQualifierDefaultValueTokenParts(
+    parts: CommonHelpers.IQualifierDefaultValueTokenParts
+  ): Result<IValidatedQualifierDefaultValueDecl> {
+    return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, this.qualifiers);
+  }
+
+  /**
+   * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.
+   * @param token - the qualifier default values token to convert
+   * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.
+   */
+  public qualifierDefaultValuesTokenToDecl(token: string): Result<IValidatedQualifierDefaultValuesDecl> {
+    return QualifierDefaultValueTokens.qualifierDefaultValuesTokenToDecl(token, this.qualifiers);
+  }
+
+  /**
+   * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.
+   * @param decl - the validated qualifier default values declaration to convert
+   * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.
+   */
+  public declToQualifierDefaultValuesToken(decl: IValidatedQualifierDefaultValuesDecl): Result<string> {
+    return QualifierDefaultValueTokens.declToQualifierDefaultValuesToken(decl);
+  }
+
+  /**
+   * Parses a {@link QualifierDefaultValueToken | qualifier default value 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 Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,
+   * `Failure` with an error message if not.
+   */
+  public static parseQualifierDefaultValueToken(
+    token: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedQualifierDefaultValueDecl> {
+    return CommonHelpers.parseQualifierDefaultValueTokenParts(token).onSuccess((parts) => {
+      return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, qualifiers);
+    });
+  }
+
+  /**
+   * Parses a {@link QualifierDefaultValuesToken | qualifier default values 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 Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}
+   * if successful, `Failure` with an error message if not
+   */
+  public static parseQualifierDefaultValuesToken(
+    token: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedQualifierDefaultValueDecl[]> {
+    return CommonHelpers.parseQualifierDefaultValuesTokenParts(token).onSuccess((parts) => {
+      return mapResults(
+        parts.map((part) =>
+          QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(part, qualifiers)
+        )
+      );
+    });
+  }
+
+  /**
+   * Validates the parts of a qualifier default value token against the qualifiers present in the supplied
+   * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+   * @param parts - the {@link Helpers.IQualifierDefaultValueTokenParts | qualifier default value token parts} to validate.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to
+   * validate qualifier names and values.
+   * @returns `Success` with a {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,
+   * `Failure` with an error message if not.
+   */
+  public static validateQualifierDefaultValueTokenParts(
+    parts: CommonHelpers.IQualifierDefaultValueTokenParts,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedQualifierDefaultValueDecl> {
+    return qualifiers.getByNameOrToken(parts.qualifier).onSuccess((qualifier) => {
+      // Allow empty values to remove defaults
+      if (parts.value === '') {
+        return succeed({ qualifier, value: '' as QualifierContextValue });
+      }
+
+      return qualifier.type
+        .validateContextValue(parts.value)
+        .onSuccess((value) => {
+          return succeed({ qualifier, value });
+        })
+        .withDetail('failure', 'success');
+    });
+  }
+
+  /**
+   * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.
+   * @param token - the qualifier default values token to convert
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+   * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.
+   */
+  public static qualifierDefaultValuesTokenToDecl(
+    token: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedQualifierDefaultValuesDecl> {
+    return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, qualifiers).onSuccess(
+      (qualifierDefaultValues) => {
+        const defaultValues: IValidatedQualifierDefaultValuesDecl = {};
+
+        for (const { qualifier, value } of qualifierDefaultValues) {
+          const qualifierName = qualifier.name as QualifierName;
+          const contextValue = value as QualifierContextValue;
+
+          // Check for duplicate qualifiers
+          if (qualifierName in defaultValues) {
+            return fail(`${qualifier.name}: duplicate qualifier in default values token`);
+          }
+
+          // Only add non-empty values (empty values remove defaults)
+          if (contextValue !== '') {
+            defaultValues[qualifierName] = contextValue;
+          }
+        }
+
+        return succeed(defaultValues);
+      }
+    );
+  }
+
+  /**
+   * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.
+   * @param decl - the validated qualifier default values declaration to convert
+   * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.
+   */
+  public static declToQualifierDefaultValuesToken(
+    decl: IValidatedQualifierDefaultValuesDecl
+  ): Result<string> {
+    const tokens: string[] = [];
+
+    for (const [qualifierName, contextValue] of Object.entries(decl)) {
+      // Build token as "qualifier=value"
+      tokens.push(`${qualifierName}=${contextValue}`);
+    }
+
+    if (tokens.length === 0) {
+      return succeed('');
+    }
+
+    const tokenString = tokens.join('|');
+
+    // Validate the generated token
+    return CommonHelpers.buildQualifierDefaultValuesToken(
+      tokens.map((token) => {
+        const [qualifier, value] = token.split('=');
+        return { qualifier, value };
+      })
+    ).onSuccess(() => succeed(tokenString));
+  }
+}

package/src/packlets/resource-json/compiled/common.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Options for controlling the compilation of resource objects.
+ * @public
+ */
+export interface ICompiledResourceOptions {
+  /**
+   * Whether to include metadata in the compiled objects.
+   * Metadata includes human-readable information like semantic keys
+   * that can be useful for debugging or tooling.
+   * @defaultValue false
+   */
+  includeMetadata?: boolean;
+}

package/src/packlets/resource-json/compiled/convert.ts

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as Common from '../../common';
+import { Converters } from '@fgv/ts-utils';
+import { Converters as JsonConverters } from '@fgv/ts-json-base';
+import * as Model from './json';
+
+/* eslint-disable @rushstack/typedef-var */
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionMetadata | compiled condition metadata}.
+ * @public
+ */
+export const compiledConditionMetadata = Converters.strictObject<Model.ICompiledConditionMetadata>({
+  key: Common.Convert.conditionKey
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSetMetadata | compiled condition set metadata}.
+ * @public
+ */
+export const compiledConditionSetMetadata = Converters.strictObject<Model.ICompiledConditionSetMetadata>({
+  key: Common.Convert.conditionSetKey
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledDecisionMetadata | compiled decision metadata}.
+ * @public
+ */
+export const compiledDecisionMetadata = Converters.strictObject<Model.ICompiledDecisionMetadata>({
+  key: Common.Convert.decisionKey
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledQualifierType | compiled qualifier type}.
+ * @public
+ */
+export const compiledQualifierType = Converters.strictObject<Model.ICompiledQualifierType>({
+  name: Common.Convert.qualifierTypeName
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledQualifier | compiled qualifier}.
+ * @public
+ */
+export const compiledQualifier = Converters.strictObject<Model.ICompiledQualifier>({
+  name: Common.Convert.qualifierName,
+  type: Common.Convert.qualifierTypeIndex,
+  defaultPriority: Common.Convert.conditionPriority
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResourceType | compiled resource type}.
+ * @public
+ */
+export const compiledResourceType = Converters.strictObject<Model.ICompiledResourceType>({
+  name: Common.Convert.resourceTypeName
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledCondition | compiled condition}.
+ * @public
+ */
+export const compiledCondition = Converters.strictObject<Model.ICompiledCondition>({
+  qualifierIndex: Common.Convert.qualifierIndex,
+  operator: Common.Convert.conditionOperator.optional(),
+  value: Converters.string,
+  priority: Common.Convert.conditionPriority,
+  scoreAsDefault: Common.Convert.qualifierMatchScore.optional(),
+  metadata: compiledConditionMetadata.optional()
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSet | compiled condition set}.
+ * @public
+ */
+export const compiledConditionSet = Converters.strictObject<Model.ICompiledConditionSet>({
+  conditions: Converters.arrayOf(Common.Convert.conditionIndex),
+  metadata: compiledConditionSetMetadata.optional()
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledAbstractDecision | compiled abstract decision}.
+ * @public
+ */
+export const compiledAbstractDecision = Converters.strictObject<Model.ICompiledAbstractDecision>({
+  conditionSets: Converters.arrayOf(Common.Convert.conditionSetIndex),
+  metadata: compiledDecisionMetadata.optional()
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledCandidate | compiled candidate}.
+ * @public
+ */
+export const compiledCandidate = Converters.strictObject<Model.ICompiledCandidate>({
+  json: JsonConverters.jsonValue,
+  isPartial: Converters.boolean,
+  mergeMethod: Common.Convert.resourceValueMergeMethod
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResource | compiled resource}.
+ * @public
+ */
+export const compiledResource = Converters.strictObject<Model.ICompiledResource>({
+  id: Common.Convert.resourceId,
+  type: Common.Convert.resourceTypeIndex,
+  decision: Common.Convert.decisionIndex,
+  candidates: Converters.arrayOf(compiledCandidate)
+});
+
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResourceCollection | compiled resource collection}.
+ * This combines all the individual converters into a single converter for the entire resource collection.
+ * @public
+ */
+export const compiledResourceCollection = Converters.strictObject<Model.ICompiledResourceCollection>({
+  qualifiers: Converters.arrayOf(compiledQualifier),
+  qualifierTypes: Converters.arrayOf(compiledQualifierType),
+  resourceTypes: Converters.arrayOf(compiledResourceType),
+  conditions: Converters.arrayOf(compiledCondition),
+  conditionSets: Converters.arrayOf(compiledConditionSet),
+  decisions: Converters.arrayOf(compiledAbstractDecision),
+  resources: Converters.arrayOf(compiledResource)
+});

package/src/packlets/resource-json/compiled/index.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import * as Convert from './convert';
+
+export * from './common';
+export * from './json';
+export { Convert };

package/src/packlets/resource-json/compiled/json.ts

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as Common from '../../common';
+import { JsonValue } from '@fgv/ts-json-base';
+
+/**
+ * Metadata for a compiled condition, containing human-readable information.
+ * @public
+ */
+export interface ICompiledConditionMetadata {
+  /**
+   * The semantic key of the condition (e.g., "language=en-US").
+   */
+  key: Common.ConditionKey;
+}
+
+/**
+ * Metadata for a compiled condition set, containing human-readable information.
+ * @public
+ */
+export interface ICompiledConditionSetMetadata {
+  /**
+   * The semantic key of the condition set (e.g., "language=en-US,territory=US").
+   */
+  key: Common.ConditionSetKey;
+}
+
+/**
+ * Metadata for a compiled decision, containing human-readable information.
+ * @public
+ */
+export interface ICompiledDecisionMetadata {
+  /**
+   * The semantic key of the decision (e.g., "language=en-US,territory=US OR language=fr,territory=CA").
+   */
+  key: Common.DecisionKey;
+}
+
+/**
+ * Represents a compiled qualifier type with a name.
+ * @public
+ */
+export interface ICompiledQualifierType {
+  /**
+   * The name of the qualifier type.
+   */
+  name: Common.QualifierTypeName;
+}
+
+/**
+ * Represents a compiled qualifier with a name and type reference.
+ * @public
+ */
+export interface ICompiledQualifier {
+  /**
+   * The name of the qualifier.
+   */
+  name: Common.QualifierName;
+  /**
+   * Index reference to the qualifier type.
+   */
+  type: Common.QualifierTypeIndex;
+
+  /**
+   * The token used to identify the qualifier in resource names or paths.
+   */
+  defaultPriority: Common.ConditionPriority;
+}
+
+/**
+ * Represents a compiled resource type with a name.
+ * @public
+ */
+export interface ICompiledResourceType {
+  /**
+   * The name of the resource type.
+   */
+  name: Common.ResourceTypeName;
+}
+
+/**
+ * Represents a compiled condition used for resource selection.
+ * @public
+ */
+export interface ICompiledCondition {
+  /**
+   * Index reference to the qualifier being evaluated.
+   */
+  qualifierIndex: Common.QualifierIndex;
+  /**
+   * Optional operator to apply in the condition evaluation.
+   */
+  operator?: Common.ConditionOperator;
+  /**
+   * The value to compare against when evaluating the condition.
+   */
+  value: string;
+  /**
+   * The priority of the condition when multiple conditions match.
+   */
+  priority: Common.ConditionPriority;
+  /**
+   * Optional score to use when treating this condition as a default.
+   */
+  scoreAsDefault?: Common.QualifierMatchScore;
+  /**
+   * Optional metadata containing human-readable information about this condition.
+   */
+  metadata?: ICompiledConditionMetadata;
+}
+
+/**
+ * Represents a compiled set of conditions that must be satisfied together.
+ * @public
+ */
+export interface ICompiledConditionSet {
+  /**
+   * Array of indices referencing the conditions in this set.
+   */
+  conditions: ReadonlyArray<Common.ConditionIndex>;
+  /**
+   * Optional metadata containing human-readable information about this condition set.
+   */
+  metadata?: ICompiledConditionSetMetadata;
+}
+
+/**
+ * Represents a compiled abstract decision with condition sets.
+ * @public
+ */
+export interface ICompiledAbstractDecision {
+  /**
+   * Array of indices referencing the condition sets for this decision.
+   */
+  conditionSets: ReadonlyArray<Common.ConditionSetIndex>;
+  /**
+   * Optional metadata containing human-readable information about this decision.
+   */
+  metadata?: ICompiledDecisionMetadata;
+}
+
+/**
+ * Represents a compiled resource candidate with JSON value and merge properties.
+ * @public
+ */
+export interface ICompiledCandidate {
+  /**
+   * The JSON value of the candidate.
+   */
+  json: JsonValue;
+  /**
+   * Indicates if this is a partial resource that needs to be merged.
+   */
+  isPartial: boolean;
+  /**
+   * The method to use when merging this candidate with others.
+   */
+  mergeMethod: Common.ResourceValueMergeMethod;
+}
+
+/**
+ * Represents a compiled resource with an identifier and associated candidates.
+ * @public
+ */
+export interface ICompiledResource {
+  /**
+   * The unique identifier of the resource.
+   */
+  id: Common.ResourceId;
+
+  /**
+   * Index reference to the resource type of this resource.
+   */
+  type: Common.ResourceTypeIndex;
+
+  /**
+   * Index reference to the decision that determines when this resource applies.
+   */
+  decision: Common.DecisionIndex;
+  /**
+   * Array of candidate values for this resource.
+   */
+  candidates: ReadonlyArray<ICompiledCandidate>;
+}
+
+/**
+ * Represents a complete compiled collection of resources with their associated
+ * qualifiers, types, conditions, and decisions.
+ * @public
+ */
+export interface ICompiledResourceCollection {
+  /**
+   * Array of all qualifier types in the collection.
+   */
+  qualifierTypes: ReadonlyArray<ICompiledQualifierType>;
+  /**
+   * Array of all qualifiers in the collection.
+   */
+  qualifiers: ReadonlyArray<ICompiledQualifier>;
+  /**
+   * Array of all resource types in the collection.
+   */
+  resourceTypes: ReadonlyArray<ICompiledResourceType>;
+  /**
+   * Array of all conditions in the collection.
+   */
+  conditions: ReadonlyArray<ICompiledCondition>;
+  /**
+   * Array of all condition sets in the collection.
+   */
+  conditionSets: ReadonlyArray<ICompiledConditionSet>;
+  /**
+   * Array of all decisions in the collection.
+   */
+  decisions: ReadonlyArray<ICompiledAbstractDecision>;
+  /**
+   * Array of all resources in the collection.
+   */
+  resources: ReadonlyArray<ICompiledResource>;
+}