@fgv/ts-res 5.0.1-1 → 5.0.1-10

package/dist/test/unit/qualifier-types/testQualifierType.js

@@ -0,0 +1,76 @@
+/*
+ * 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 { captureResult, fail, succeed } from '@fgv/ts-utils';
+import * as TsRes from '../../../index';
+export class TestQualifierType extends TsRes.QualifierTypes.QualifierType {
+    constructor(params) {
+        var _a;
+        super({
+            name: (_a = params === null || params === void 0 ? void 0 : params.name) !== null && _a !== void 0 ? _a : 'test',
+            allowContextList: (params === null || params === void 0 ? void 0 : params.allowContextList) === 'true',
+            index: params === null || params === void 0 ? void 0 : params.index
+        });
+        this.systemTypeName = TsRes.Convert.qualifierTypeName
+            .convert('test')
+            .orThrow();
+    }
+    static create(params) {
+        return captureResult(() => new TestQualifierType(params));
+    }
+    isValidConditionValue(value) {
+        return true;
+    }
+    validateCondition(value, operator) {
+        return this.isValidConditionValue(value) ? succeed(value) : fail(`Invalid condition value: ${value}`);
+    }
+    getConfigurationJson() {
+        return succeed({
+            name: this.name,
+            systemType: 'test',
+            configuration: {}
+        });
+    }
+    validateConfigurationJson(from) {
+        // Simple validation for test class
+        if (typeof from !== 'object' || from === null) {
+            return fail('Expected object');
+        }
+        const obj = from;
+        if (typeof obj.name !== 'string') {
+            return fail('name must be string');
+        }
+        if (obj.systemType !== 'test') {
+            return fail('systemType must be test');
+        }
+        return succeed(from);
+    }
+    _matchOne(condition, context, operator) {
+        if (condition === context) {
+            return TsRes.PerfectMatch;
+        }
+        if (condition.toLowerCase() === context.toLowerCase()) {
+            return 0.5;
+        }
+        return TsRes.NoMatch;
+    }
+}
+//# sourceMappingURL=testQualifierType.js.map

package/dist/test/unit/resource-types/testDerivedResourceType.js

@@ -0,0 +1,109 @@
+/*
+ * 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 { captureResult, fail, succeed } from '@fgv/ts-utils';
+import { Convert } from '../../../packlets/common';
+// eslint-disable-next-line @rushstack/packlets/mechanics
+import { ResourceType } from '../../../packlets/resource-types/resourceType';
+/**
+ * A derived resource type for testing that demonstrates:
+ * 1. Custom validation logic
+ * 2. Using a resource resolver to look up template values
+ * 3. Type-specific defaults and error handling
+ */
+export class TestDerivedResourceType extends ResourceType {
+    constructor(key, index, template, templateResourceId) {
+        super(key, index, template);
+        this.systemTypeName = Convert.resourceTypeName
+            .convert('test-derived')
+            .orThrow();
+        this._templateResourceId = templateResourceId;
+    }
+    /**
+     * Factory method to create a new TestDerivedResourceType instance.
+     */
+    static create(params) {
+        var _a;
+        return Convert.resourceTypeName.convert((_a = params === null || params === void 0 ? void 0 : params.key) !== null && _a !== void 0 ? _a : 'test-derived').onSuccess((key) => {
+            return captureResult(() => new TestDerivedResourceType(key, params === null || params === void 0 ? void 0 : params.index, params === null || params === void 0 ? void 0 : params.template, params === null || params === void 0 ? void 0 : params.templateResourceId));
+        });
+    }
+    /**
+     * Validates a resource candidate declaration with custom logic.
+     */
+    validateDeclaration(props) {
+        // Custom validation: merge method must be 'replace' for full candidates
+        if (props.completeness === 'full' && props.mergeMethod !== 'replace') {
+            return fail(`${this.key}: Full candidates must use 'replace' merge method, got '${props.mergeMethod}'`);
+        }
+        return this.validate(props.json, props.completeness);
+    }
+    validate(json, completeness) {
+        if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+            return fail(`${this.key}: Expected JSON object, got ${typeof json}`);
+        }
+        const obj = json;
+        // Validate required title field for full resources
+        if (completeness === 'full' && (typeof obj.title !== 'string' || !obj.title.trim())) {
+            return fail(`${this.key}: 'title' field is required and must be a non-empty string`);
+        }
+        // Validate optional description
+        if (obj.description !== undefined && typeof obj.description !== 'string') {
+            return fail(`${this.key}: 'description' field must be a string if provided`);
+        }
+        // Validate optional metadata
+        if (obj.metadata !== undefined) {
+            if (typeof obj.metadata !== 'object' || obj.metadata === null || Array.isArray(obj.metadata)) {
+                return fail(`${this.key}: 'metadata' field must be an object if provided`);
+            }
+        }
+        const result = Object.assign(Object.assign(Object.assign({}, (obj.title && { title: obj.title })), (obj.description && { description: obj.description })), (obj.metadata && { metadata: obj.metadata }));
+        return succeed(result);
+    }
+    /**
+     * Override to demonstrate looking up template values from another resource.
+     */
+    getDefaultTemplateCandidate(json, conditions, resolver) {
+        // If a template resource ID is configured and resolver is available, try to resolve it
+        if (this._templateResourceId && resolver && !json) {
+            return resolver
+                .resolveComposedResourceValue(this._templateResourceId)
+                .onFailure((error) => fail(`${this.key}: Failed to resolve template resource '${this._templateResourceId}': ${error}`))
+                .onSuccess((resolvedValue) => {
+                // Use the resolved value as our JSON template
+                return super.getDefaultTemplateCandidate(resolvedValue, conditions, resolver);
+            });
+        }
+        // Use provided JSON or fall back to base implementation
+        return super.getDefaultTemplateCandidate(json, conditions, resolver);
+    }
+    /**
+     * Override createTemplate to add additional validation for the derived type.
+     */
+    createTemplate(resourceId, init, conditions, resolver) {
+        // Additional validation: warn if trying to use resolver functionality without a resolver
+        if (this._templateResourceId && !resolver) {
+            return fail(`${this.key}: Template resource ID '${this._templateResourceId}' is configured but no resolver provided`);
+        }
+        return super.createTemplate(resourceId, init, conditions, resolver);
+    }
+}
+//# sourceMappingURL=testDerivedResourceType.js.map

package/dist/test/unit/resources/deltaGenerator.helpers.js

@@ -0,0 +1,282 @@
+/*
+ * 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 '@fgv/ts-utils-jest';
+import { succeed, fail } from '@fgv/ts-utils';
+import * as TsRes from '../../../index';
+/**
+ * Common test data and setup utilities for DeltaGenerator tests
+ */
+// Test resource candidates for baseline and delta scenarios
+export const baselineResources = [
+    {
+        id: 'greeting.hello',
+        json: { message: 'Hello', casual: 'Hi' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    {
+        id: 'greeting.goodbye',
+        json: { message: 'Goodbye', casual: 'Bye' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    {
+        id: 'numbers.count',
+        json: { one: 'one', two: 'two', three: 'three' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    }
+];
+export const deltaResources = [
+    // Updated resource - some changes
+    {
+        id: 'greeting.hello',
+        json: { message: 'Hello World', casual: 'Hi there' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    // New resource - not in baseline
+    {
+        id: 'greeting.welcome',
+        json: { message: 'Welcome', casual: 'Hey' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    // Unchanged resource - identical to baseline
+    {
+        id: 'numbers.count',
+        json: { one: 'one', two: 'two', three: 'three' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    }
+];
+/**
+ * Creates the base test setup with qualifier types, qualifiers, and resource types
+ */
+export function createBaseTestSetup() {
+    // Set up qualifier types
+    const qualifierTypes = TsRes.QualifierTypes.QualifierTypeCollector.create({
+        qualifierTypes: [
+            TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
+            TsRes.QualifierTypes.TerritoryQualifierType.create().orThrow()
+        ]
+    }).orThrow();
+    // Set up qualifiers
+    const qualifiers = TsRes.Qualifiers.QualifierCollector.create({
+        qualifierTypes,
+        qualifiers: [
+            { name: 'language', typeName: 'language', defaultPriority: 100 },
+            { name: 'territory', typeName: 'territory', defaultPriority: 90 }
+        ]
+    }).orThrow();
+    // Set up resource types
+    const resourceTypes = TsRes.ResourceTypes.ResourceTypeCollector.create({
+        resourceTypes: [TsRes.ResourceTypes.JsonResourceType.create().orThrow()]
+    }).orThrow();
+    // Set up context provider
+    const contextProvider = TsRes.Runtime.ValidatingSimpleContextQualifierProvider.create({
+        qualifiers,
+        qualifierValues: {
+            language: 'en',
+            territory: 'US'
+        }
+    }).orThrow();
+    return {
+        qualifierTypes,
+        qualifiers,
+        resourceTypes,
+        contextProvider
+    };
+}
+/**
+ * Creates a mock logger for testing
+ */
+export function createMockLogger() {
+    return {
+        logLevel: 'detail',
+        log: jest.fn(),
+        detail: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn()
+    };
+}
+/**
+ * Creates a resource manager with baseline resources
+ */
+export function createResourceManagerWithBaseline(qualifiers, resourceTypes, resources = baselineResources) {
+    const resourceManager = TsRes.Resources.ResourceManagerBuilder.create({
+        qualifiers,
+        resourceTypes
+    }).orThrow();
+    // Add resources
+    resources.forEach((resource) => {
+        resourceManager.addLooseCandidate(resource).orThrow();
+    });
+    return resourceManager;
+}
+/**
+ * Creates a baseline resolver with the given resources
+ */
+export function createBaselineResolver(resourceManager, qualifierTypes, contextProvider) {
+    const builtManager = resourceManager.build().orThrow();
+    return TsRes.Runtime.ResourceResolver.create({
+        resourceManager: builtManager,
+        qualifierTypes,
+        contextQualifierProvider: contextProvider
+    }).orThrow();
+}
+/**
+ * Creates a delta resolver with the given resources
+ */
+export function createDeltaResolver(resources, qualifiers, resourceTypes, qualifierTypes, contextProvider) {
+    const deltaManager = TsRes.Resources.ResourceManagerBuilder.create({
+        qualifiers,
+        resourceTypes
+    }).orThrow();
+    resources.forEach((resource) => {
+        deltaManager.addLooseCandidate(resource).orThrow();
+    });
+    const builtDeltaManager = deltaManager.build().orThrow();
+    return TsRes.Runtime.ResourceResolver.create({
+        resourceManager: builtDeltaManager,
+        qualifierTypes,
+        contextQualifierProvider: contextProvider
+    }).orThrow();
+}
+/**
+ * Creates a complete test setup with all required objects
+ */
+export function createCompleteTestSetup() {
+    const baseSetup = createBaseTestSetup();
+    const mockLogger = createMockLogger();
+    const resourceManager = createResourceManagerWithBaseline(baseSetup.qualifiers, baseSetup.resourceTypes);
+    return Object.assign(Object.assign({}, baseSetup), { resourceManager,
+        mockLogger });
+}
+/**
+ * Test data for various test scenarios
+ */
+export const testData = {
+    // Resources with language variations
+    languageResources: {
+        baseline: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-US' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'Goodbye' },
+                conditions: { language: 'en-US' },
+                resourceTypeName: 'json'
+            }
+        ],
+        britishEnglish: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'Cheerio' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.thanks',
+                json: { message: 'Cheers' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            }
+        ],
+        canadianEnglish: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'See ya' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.apology',
+                json: { message: 'Sorry' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            }
+        ]
+    },
+    // Empty scenarios
+    emptyResources: [],
+    // Complex nested resources
+    complexResources: [
+        {
+            id: 'app.config',
+            json: {
+                settings: {
+                    theme: 'dark',
+                    notifications: {
+                        enabled: true,
+                        frequency: 'daily',
+                        types: ['email', 'push']
+                    }
+                },
+                metadata: {
+                    version: '1.0.0',
+                    lastUpdated: '2025-01-01'
+                }
+            },
+            conditions: { language: 'en' },
+            resourceTypeName: 'json'
+        }
+    ]
+};
+/**
+ * Helper to create a failing resolver for error testing
+ */
+export function createFailingResolver(errorMessage) {
+    return {
+        resourceIds: [],
+        resolveComposedResourceValue: jest.fn().mockReturnValue(fail(errorMessage)),
+        withContext: jest.fn().mockReturnValue(succeed({}))
+    };
+}
+/**
+ * Helper to create a custom resolver with specific behavior
+ */
+export function createCustomResolver(resolveImpl, resourceIds = []) {
+    return {
+        resourceIds,
+        resolveComposedResourceValue: jest.fn().mockImplementation(resolveImpl),
+        withContext: jest.fn().mockReturnValue(succeed({}))
+    };
+}
+//# sourceMappingURL=deltaGenerator.helpers.js.map

package/dist/ts-res.d.ts

@@ -7,7 +7,7 @@ import { FileTree } from '@fgv/ts-json-base';
 import { Hash } from '@fgv/ts-utils';
 import { ICollectible } from '@fgv/ts-utils';
 import { IReadOnlyResultMap } from '@fgv/ts-utils';
-import { JsonCompatible } from '@fgv/ts-json-base';
+import { JsonCompatibleType } from '@fgv/ts-json-base';
 import { JsonObject } from '@fgv/ts-json-base';
 import { JsonValue } from '@fgv/ts-json-base';
 import { Logging } from '@fgv/ts-utils';
@@ -2876,7 +2876,7 @@ declare function getDirectoryName(path: string): string;
 /**
  * Gets the name for a resource ID.
  * @param id - The resource ID to get the name for.
- * @returns The resource name if found, or undefined if not.
+ * @returns `Success` with the resource name if found, or `Failure` with an error message if not.
  * @public
  */
 declare function getNameForResourceId(id: string | undefined): Result<ResourceName>;
@@ -4960,13 +4960,13 @@ declare interface IQualifierType<TCFGJSON extends JsonObject = JsonObject> exten
      * Gets the configuration for this qualifier type.
      * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
-    getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    getConfigurationJson(): Result<JsonCompatibleType<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * Validates configuration JSON data for this qualifier type.
      * @param from - The unknown data to validate as configuration JSON.
      * @returns `Success` with validated JSON configuration if valid, `Failure` with an error message otherwise.
      */
-    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
 }
 
 /**
@@ -6568,7 +6568,7 @@ declare const LanguagePrioritySystemConfiguration: ISystemConfiguration;
  * Accepts a list of language tags in the context by default.
  * @public
  */
-declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config_2.ILanguageQualifierTypeConfig>> {
+declare class LanguageQualifierType extends QualifierType<JsonCompatibleType<Config_2.ILanguageQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -6611,11 +6611,11 @@ declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config_
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
+    getConfigurationJson(): Result<JsonCompatibleType<Config_2.ISystemLanguageQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config_2.ISystemLanguageQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.
@@ -6646,7 +6646,7 @@ declare const languageQualifierTypeConfig: ObjectConverter<Model_2.ILanguageQual
  * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
-declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config_2.ILiteralQualifierTypeConfig>> {
+declare class LiteralQualifierType extends QualifierType<JsonCompatibleType<Config_2.ILiteralQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -6695,11 +6695,11 @@ declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config_2
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
+    getConfigurationJson(): Result<JsonCompatibleType<Config_2.ISystemLiteralQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config_2.ISystemLiteralQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.
@@ -7717,11 +7717,11 @@ export declare abstract class QualifierType<TCFGJSON extends JsonObject = JsonOb
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    abstract getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    abstract getConfigurationJson(): Result<JsonCompatibleType<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    abstract validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    abstract validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
      */
@@ -10010,7 +10010,7 @@ declare const TerritoryPrioritySystemConfiguration: ISystemConfiguration;
  * implementation handles incorrect casing.
  * @public
  */
-declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config_2.ITerritoryQualifierTypeConfig>> {
+declare class TerritoryQualifierType extends QualifierType<JsonCompatibleType<Config_2.ITerritoryQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -10065,11 +10065,11 @@ declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
+    getConfigurationJson(): Result<JsonCompatibleType<Config_2.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config_2.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.52.12"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/index.browser.d.ts

@@ -0,0 +1,24 @@
+import * as Bundle from './packlets/bundle';
+import * as QualifierTypes from './packlets/qualifier-types';
+import * as Qualifiers from './packlets/qualifiers';
+import * as Conditions from './packlets/conditions';
+import * as Config from './packlets/config/index.browser';
+import * as Context from './packlets/context';
+import * as Decisions from './packlets/decisions';
+import * as ResourceJson from './packlets/resource-json';
+import * as Resources from './packlets/resources';
+import * as ResourceTypes from './packlets/resource-types';
+import * as Import from './packlets/import/index.browser';
+import * as Runtime from './packlets/runtime';
+import * as ZipArchive from './packlets/zip-archive/index.browser';
+export * from './packlets/common';
+import { Condition, ConditionSet } from './packlets/conditions';
+import { Decision } from './packlets/decisions';
+import { QualifierType } from './packlets/qualifier-types';
+import { Qualifier } from './packlets/qualifiers';
+import { ResourceType } from './packlets/resource-types';
+import { Resource, ResourceCandidate, ResourceManagerBuilder } from './packlets/resources';
+import { IResourceManager, ResourceResolver } from './packlets/runtime';
+import { BundleBuilder, BundleLoader } from './packlets/bundle';
+export { Bundle, BundleBuilder, BundleLoader, Condition, Conditions, ConditionSet, Config, Context, Decision, Decisions, Import, IResourceManager, Qualifier, QualifierType, QualifierTypes, Qualifiers, Resource, ResourceCandidate, ResourceJson, ResourceResolver, ResourceManagerBuilder, ResourceType, ResourceTypes, Resources, Runtime, ZipArchive };
+//# sourceMappingURL=index.browser.d.ts.map