@umbraco-cms/backoffice 18.3.0-rc → 19.0.0-beta1

package/dist-cms/packages/core/variant/utils/variant-ids-to-cultures.function.js

@@ -0,0 +1,10 @@
+/**
+ * Maps variant ids to their distinct cultures. Missing variant ids are skipped, so the result never contains `undefined`.
+ * The invariant culture is represented as `null` and is kept in the result; filter it out locally where it is not wanted.
+ * @param {Array<UmbVariantId | undefined>} variantIds - The variant ids to map.
+ * @returns {Array<string | null>} The distinct cultures, in order of first occurrence.
+ */
+export function umbVariantIdsToCultures(variantIds) {
+    const cultures = variantIds.filter((x) => x !== undefined).map((x) => x.culture);
+    return [...new Set(cultures)];
+}

package/dist-cms/packages/core/variant/{variant-object-compare.function.d.ts → utils/variant-object-compare.function.d.ts}

@@ -1,4 +1,4 @@
-import type { UmbObjectWithVariantProperties } from './types.js';
+import type { UmbObjectWithVariantProperties } from '../types.js';
 /**
  * Compares the culture and segment of two variant objects.
  * @param {UmbObjectWithVariantProperties} a - the first object to compare.

package/dist-cms/packages/core/variant/utils/variant-object-sort-compare.function.d.ts

@@ -0,0 +1,22 @@
+type UmbSortableVariantObject = {
+    culture?: string | null;
+    segment?: string | null;
+};
+/**
+ * Compares two culture or segment codes, invariant (nullish) first, then ordinally and case-sensitively,
+ * matching .NET's `StringComparer.Ordinal`.
+ * @param {string | null | undefined} a - The first code to compare.
+ * @param {string | null | undefined} b - The second code to compare.
+ * @returns {number} A negative number if `a` sorts before `b`, positive if after, zero if equal.
+ */
+export declare function umbVariantCodeSortCompare(a: string | null | undefined, b: string | null | undefined): number;
+/**
+ * Compares two variant objects by culture, then by segment, in the order the Management API returns
+ * variant collections in (invariant first, then ordinal and case-sensitive).
+ * This is not the display order of `sortVariants`, which prioritizes default language, mandatory state and publish state.
+ * @param {UmbSortableVariantObject} a - The first object to compare.
+ * @param {UmbSortableVariantObject} b - The second object to compare.
+ * @returns {number} A negative number if `a` sorts before `b`, positive if after, zero if equal.
+ */
+export declare function umbVariantObjectSortCompare(a: UmbSortableVariantObject, b: UmbSortableVariantObject): number;
+export {};

package/dist-cms/packages/core/variant/utils/variant-object-sort-compare.function.js

@@ -0,0 +1,29 @@
+/**
+ * Compares two culture or segment codes, invariant (nullish) first, then ordinally and case-sensitively,
+ * matching .NET's `StringComparer.Ordinal`.
+ * @param {string | null | undefined} a - The first code to compare.
+ * @param {string | null | undefined} b - The second code to compare.
+ * @returns {number} A negative number if `a` sorts before `b`, positive if after, zero if equal.
+ */
+export function umbVariantCodeSortCompare(a, b) {
+    const normalizedA = a ?? null;
+    const normalizedB = b ?? null;
+    if (normalizedA === normalizedB)
+        return 0;
+    if (normalizedA === null)
+        return -1;
+    if (normalizedB === null)
+        return 1;
+    return normalizedA < normalizedB ? -1 : 1;
+}
+/**
+ * Compares two variant objects by culture, then by segment, in the order the Management API returns
+ * variant collections in (invariant first, then ordinal and case-sensitive).
+ * This is not the display order of `sortVariants`, which prioritizes default language, mandatory state and publish state.
+ * @param {UmbSortableVariantObject} a - The first object to compare.
+ * @param {UmbSortableVariantObject} b - The second object to compare.
+ * @returns {number} A negative number if `a` sorts before `b`, positive if after, zero if equal.
+ */
+export function umbVariantObjectSortCompare(a, b) {
+    return umbVariantCodeSortCompare(a.culture, b.culture) || umbVariantCodeSortCompare(a.segment, b.segment);
+}

package/dist-cms/packages/core/variant/variant-id.class.d.ts

@@ -3,33 +3,147 @@ export declare const UMB_INVARIANT_CULTURE = "invariant";
 /**
  * An identifier representing a Variant. This is at current state a culture and a segment.
  * The identifier is not specific for ContentType Variants, but is used for many type of identification of a culture and a segment. One case is any property of a ContentType can be resolved into a VariantId depending on their structural settings such as Vary by Culture and Vary by Segmentation.
+ *
+ * Instances are immutable. Methods that derive a variant return a new instance rather than modifying this one.
  */
 export declare class UmbVariantId {
     /**
-     * A frozen instance of the UmbVariantId class representing the invariant variant, meaning it has no culture and no segment.
+     * A shared instance representing the invariant variant, meaning it has no culture and no segment.
      */
     static readonly INVARIANT: Readonly<UmbVariantId>;
+    /**
+     * Creates a Variant Id from an object holding a culture and a segment.
+     * @param {UmbObjectWithVariantProperties} variantData - The object to read the culture and segment from.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static Create(variantData: UmbObjectWithVariantProperties): UmbVariantId;
+    /**
+     * Creates a Variant Id from an object where the culture and/or segment may be omitted.
+     * Omitted values are treated as invariant.
+     * @param {Partial<UmbObjectWithVariantProperties>} variantData - The object to read the culture and segment from.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static CreateFromPartial(variantData: Partial<UmbObjectWithVariantProperties>): UmbVariantId;
+    /**
+     * Gets the Variant Id representing the invariant variant.
+     * @returns {UmbVariantId} The shared {@link UmbVariantId.INVARIANT} instance.
+     */
     static CreateInvariant(): UmbVariantId;
+    /**
+     * Parses a string in the format produced by {@link UmbVariantId.toString} into a Variant Id.
+     * The format is `culture` or `culture_segment`, where a culture of `invariant` means no culture.
+     * @param {string} str - The string to parse.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static FromString(str: string): UmbVariantId;
+    /**
+     * The culture of this variant, or `null` when it is culture invariant.
+     */
     readonly culture: string | null;
+    /**
+     * The segment of this variant, or `null` when it is segment invariant (unsegmented).
+     */
     readonly segment: string | null;
+    /**
+     * @param {string | null} [culture] - The culture. `null`, `undefined` and `'invariant'` all mean culture invariant.
+     * @param {string | null} [segment] - The segment. `null` and `undefined` both mean segment invariant.
+     */
     constructor(culture?: string | null, segment?: string | null);
+    /**
+     * Checks whether this Variant Id has the same culture and segment as a given object.
+     * @param {UmbObjectWithVariantProperties} obj - The object to compare with.
+     * @returns {boolean} True if both culture and segment match.
+     */
     compare(obj: UmbObjectWithVariantProperties): boolean;
+    /**
+     * Checks whether this Variant Id has the same culture and segment as another Variant Id.
+     * @param {UmbVariantId} variantId - The Variant Id to compare with.
+     * @returns {boolean} True if both culture and segment match.
+     */
     equal(variantId: UmbVariantId): boolean;
+    /**
+     * Checks whether this Variant Id is included in a given array of Variant Ids.
+     * @param {Array<UmbVariantId>} variantIds - The variant ids to check against.
+     * @returns {boolean} True if a matching variant id is found.
+     */
+    oneOf(variantIds: Array<UmbVariantId>): boolean;
+    /**
+     * Serializes this Variant Id as `culture` or `culture_segment`, using `invariant` when there is no culture.
+     * The result can be parsed back with {@link UmbVariantId.FromString}.
+     * @returns {string} The string representation.
+     */
     toString(): string;
+    /**
+     * Gets the culture part as a string.
+     * @returns {string} The culture, or `invariant` when there is no culture.
+     */
     toCultureString(): string;
+    /**
+     * Gets the segment part as a string.
+     * @returns {string} The segment, or an empty string when there is no segment.
+     */
     toSegmentString(): string;
+    /**
+     * Checks whether this Variant Id has no culture.
+     * @returns {boolean} True if the culture is invariant.
+     */
     isCultureInvariant(): boolean;
+    /**
+     * Checks whether this Variant Id has no segment.
+     * @returns {boolean} True if the segment is invariant.
+     */
     isSegmentInvariant(): boolean;
+    /**
+     * Checks whether this Variant Id has neither a culture nor a segment.
+     * @returns {boolean} True if both culture and segment are invariant.
+     */
     isInvariant(): boolean;
+    /**
+     * Creates a copy of this Variant Id.
+     * @returns {UmbVariantId} A new Variant Id with the same culture and segment.
+     */
     clone(): UmbVariantId;
+    /**
+     * Converts this Variant Id to a plain object.
+     * @returns {UmbObjectWithVariantProperties} An object holding the culture and the segment.
+     */
     toObject(): UmbObjectWithVariantProperties;
+    /**
+     * Creates a Variant Id with the same culture as this one and no segment.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toSegmentInvariant(): UmbVariantId;
+    /**
+     * Creates a Variant Id with the same segment as this one and no culture.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toCultureInvariant(): UmbVariantId;
+    /**
+     * Creates a Variant Id with the given culture and the segment of this one.
+     * @param {string | null} culture - The culture to use.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toCulture(culture: string | null): UmbVariantId;
+    /**
+     * Creates a Variant Id with the given segment and the culture of this one.
+     * @param {string | null} segment - The segment to use.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toSegment(segment: string | null): UmbVariantId;
+    /**
+     * Creates a Variant Id reduced to the dimensions that are allowed to vary.
+     * A dimension that does not vary becomes invariant.
+     * @param {boolean} [varyByCulture] - Whether to keep the culture.
+     * @param {boolean} [varyBySegment] - Whether to keep the segment.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toVariant(varyByCulture?: boolean, varyBySegment?: boolean): UmbVariantId;
+    /**
+     * Describes how a given Variant Id differs from this one, as a display string.
+     * @param {UmbVariantId} variantId - The Variant Id to compare with.
+     * @param {string} [invariantMessage] - The text used when the cultures differ.
+     * @param {string} [unsegmentedMessage] - The text used when the segments differ.
+     * @returns {string} The description, or an empty string when there are no differences.
+     */
     toDifferencesString(variantId: UmbVariantId, invariantMessage?: string, unsegmentedMessage?: string): string;
 }

package/dist-cms/packages/core/variant/variant-id.class.js

@@ -2,21 +2,44 @@ export const UMB_INVARIANT_CULTURE = 'invariant';
 /**
  * An identifier representing a Variant. This is at current state a culture and a segment.
  * The identifier is not specific for ContentType Variants, but is used for many type of identification of a culture and a segment. One case is any property of a ContentType can be resolved into a VariantId depending on their structural settings such as Vary by Culture and Vary by Segmentation.
+ *
+ * Instances are immutable. Methods that derive a variant return a new instance rather than modifying this one.
  */
 export class UmbVariantId {
     /**
-     * A frozen instance of the UmbVariantId class representing the invariant variant, meaning it has no culture and no segment.
+     * A shared instance representing the invariant variant, meaning it has no culture and no segment.
      */
     static { this.INVARIANT = Object.freeze(new UmbVariantId(null, null)); }
+    /**
+     * Creates a Variant Id from an object holding a culture and a segment.
+     * @param {UmbObjectWithVariantProperties} variantData - The object to read the culture and segment from.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static Create(variantData) {
         return Object.freeze(new UmbVariantId(variantData.culture, variantData.segment));
     }
+    /**
+     * Creates a Variant Id from an object where the culture and/or segment may be omitted.
+     * Omitted values are treated as invariant.
+     * @param {Partial<UmbObjectWithVariantProperties>} variantData - The object to read the culture and segment from.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static CreateFromPartial(variantData) {
         return Object.freeze(new UmbVariantId(variantData.culture, variantData.segment));
     }
+    /**
+     * Gets the Variant Id representing the invariant variant.
+     * @returns {UmbVariantId} The shared {@link UmbVariantId.INVARIANT} instance.
+     */
     static CreateInvariant() {
         return UmbVariantId.INVARIANT;
     }
+    /**
+     * Parses a string in the format produced by {@link UmbVariantId.toString} into a Variant Id.
+     * The format is `culture` or `culture_segment`, where a culture of `invariant` means no culture.
+     * @param {string} str - The string to parse.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     static FromString(str) {
         const firstUnderscoreIndex = str.indexOf('_');
         let culture = firstUnderscoreIndex === -1 ? str : str.substring(0, firstUnderscoreIndex);
@@ -24,58 +47,152 @@ export class UmbVariantId {
         const segment = firstUnderscoreIndex === -1 ? null : str.substring(firstUnderscoreIndex + 1) || null;
         return Object.freeze(new UmbVariantId(culture, segment));
     }
+    /**
+     * @param {string | null} [culture] - The culture. `null`, `undefined` and `'invariant'` all mean culture invariant.
+     * @param {string | null} [segment] - The segment. `null` and `undefined` both mean segment invariant.
+     */
     constructor(culture, segment) {
+        /**
+         * The culture of this variant, or `null` when it is culture invariant.
+         */
         this.culture = null;
+        /**
+         * The segment of this variant, or `null` when it is segment invariant (unsegmented).
+         */
         this.segment = null;
         this.culture = (culture === UMB_INVARIANT_CULTURE ? null : culture) ?? null;
         this.segment = segment ?? null;
     }
+    /**
+     * Checks whether this Variant Id has the same culture and segment as a given object.
+     * @param {UmbObjectWithVariantProperties} obj - The object to compare with.
+     * @returns {boolean} True if both culture and segment match.
+     */
     compare(obj) {
         return this.equal(new UmbVariantId(obj.culture, obj.segment));
     }
+    /**
+     * Checks whether this Variant Id has the same culture and segment as another Variant Id.
+     * @param {UmbVariantId} variantId - The Variant Id to compare with.
+     * @returns {boolean} True if both culture and segment match.
+     */
     equal(variantId) {
         return this.culture === variantId.culture && this.segment === variantId.segment;
     }
+    /**
+     * Checks whether this Variant Id is included in a given array of Variant Ids.
+     * @param {Array<UmbVariantId>} variantIds - The variant ids to check against.
+     * @returns {boolean} True if a matching variant id is found.
+     */
+    oneOf(variantIds) {
+        return variantIds.some((v) => v.equal(this));
+    }
+    /**
+     * Serializes this Variant Id as `culture` or `culture_segment`, using `invariant` when there is no culture.
+     * The result can be parsed back with {@link UmbVariantId.FromString}.
+     * @returns {string} The string representation.
+     */
     toString() {
         // Currently a direct copy of the VariantPropertiesObjectToString method const.
         return (this.culture || UMB_INVARIANT_CULTURE) + (this.segment ? `_${this.segment}` : '');
     }
+    /**
+     * Gets the culture part as a string.
+     * @returns {string} The culture, or `invariant` when there is no culture.
+     */
     toCultureString() {
         return this.culture || UMB_INVARIANT_CULTURE;
     }
+    /**
+     * Gets the segment part as a string.
+     * @returns {string} The segment, or an empty string when there is no segment.
+     */
     toSegmentString() {
         return this.segment || '';
     }
+    /**
+     * Checks whether this Variant Id has no culture.
+     * @returns {boolean} True if the culture is invariant.
+     */
     isCultureInvariant() {
         return this.culture === null;
     }
+    /**
+     * Checks whether this Variant Id has no segment.
+     * @returns {boolean} True if the segment is invariant.
+     */
     isSegmentInvariant() {
         return this.segment === null;
     }
+    /**
+     * Checks whether this Variant Id has neither a culture nor a segment.
+     * @returns {boolean} True if both culture and segment are invariant.
+     */
     isInvariant() {
         return this.culture === null && this.segment === null;
     }
+    /**
+     * Creates a copy of this Variant Id.
+     * @returns {UmbVariantId} A new Variant Id with the same culture and segment.
+     */
     clone() {
+        // TODO: Let's make the clone method return a frozen instance like the other methods in v.20.0 [NL]
         return new UmbVariantId(this.culture, this.segment);
     }
+    /**
+     * Converts this Variant Id to a plain object.
+     * @returns {UmbObjectWithVariantProperties} An object holding the culture and the segment.
+     */
     toObject() {
         return { culture: this.culture, segment: this.segment };
     }
+    /**
+     * Creates a Variant Id with the same culture as this one and no segment.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toSegmentInvariant() {
         return Object.freeze(new UmbVariantId(this.culture, null));
     }
+    /**
+     * Creates a Variant Id with the same segment as this one and no culture.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toCultureInvariant() {
         return Object.freeze(new UmbVariantId(null, this.segment));
     }
+    /**
+     * Creates a Variant Id with the given culture and the segment of this one.
+     * @param {string | null} culture - The culture to use.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toCulture(culture) {
         return Object.freeze(new UmbVariantId(culture, this.segment));
     }
+    /**
+     * Creates a Variant Id with the given segment and the culture of this one.
+     * @param {string | null} segment - The segment to use.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toSegment(segment) {
         return Object.freeze(new UmbVariantId(this.culture, segment));
     }
+    /**
+     * Creates a Variant Id reduced to the dimensions that are allowed to vary.
+     * A dimension that does not vary becomes invariant.
+     * @param {boolean} [varyByCulture] - Whether to keep the culture.
+     * @param {boolean} [varyBySegment] - Whether to keep the segment.
+     * @returns {UmbVariantId} A new Variant Id.
+     */
     toVariant(varyByCulture, varyBySegment) {
         return Object.freeze(new UmbVariantId(varyByCulture ? this.culture : null, varyBySegment ? this.segment : null));
     }
+    /**
+     * Describes how a given Variant Id differs from this one, as a display string.
+     * @param {UmbVariantId} variantId - The Variant Id to compare with.
+     * @param {string} [invariantMessage] - The text used when the cultures differ.
+     * @param {string} [unsegmentedMessage] - The text used when the segments differ.
+     * @returns {string} The description, or an empty string when there are no differences.
+     */
     // TODO: needs localization option:
     // TODO: Consider if this should be handled else where, it does not seem like the responsibility of this class, since it contains wordings:
     toDifferencesString(variantId, invariantMessage = 'Invariant', unsegmentedMessage = 'Unsegmented') {

package/dist-cms/packages/core/workspace/components/workspace-action-menu/workspace-action-menu.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbWorkspaceActionMenuElement extends UmbLitElement {
     private _popoverOpen;
     private _popover?;
     private _onPopoverClickCapture;
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 declare global {

package/dist-cms/packages/core/workspace/components/workspace-breadcrumb/workspace-variant-menu-breadcrumb/workspace-variant-menu-breadcrumb.element.js

@@ -89,13 +89,13 @@ let UmbWorkspaceVariantMenuBreadcrumbElement = class UmbWorkspaceVariantMenuBrea
         }
         // If the active workspace is a variant, we will try to find the matching variant name.
         if (!this._workspaceActiveVariantId?.isInvariant()) {
-            const variant = structureItem.variants.find((variantId) => this._workspaceActiveVariantId?.compare(variantId));
+            const variant = structureItem.variants.find((variant) => variant.culture === this._workspaceActiveVariantId?.culture);
             if (variant) {
                 return variant.name;
             }
         }
         // Next try to find the variant that matches the current app culture.
-        const variant = structureItem.variants.find((variant) => variant.culture === this._appCurrentCulture && variant.segment === null);
+        const variant = structureItem.variants.find((variant) => variant.culture === this._appCurrentCulture);
         if (variant) {
             if (this._workspaceActiveVariantId?.isInvariant()) {
                 // If the active variant is invariant, we return the default name as the name without parentheses.
@@ -105,12 +105,12 @@ let UmbWorkspaceVariantMenuBreadcrumbElement = class UmbWorkspaceVariantMenuBrea
             return `(${variant.name})`;
         }
         // Next try to find the variant that matches the app default culture.
-        const defaultVariant = structureItem.variants.find((variant) => variant.culture === this._appDefaultCulture && variant.segment === null);
+        const defaultVariant = structureItem.variants.find((variant) => variant.culture === this._appDefaultCulture);
         if (defaultVariant) {
             return `(${defaultVariant.name})`;
         }
         // Next try to find the invariant variant name.
-        const invariantVariant = structureItem.variants.find((variant) => variant.culture === null && variant.segment === null);
+        const invariantVariant = structureItem.variants.find((variant) => variant.culture === null);
         if (invariantVariant) {
             return invariantVariant.name;
         }

package/dist-cms/packages/core/workspace/components/workspace-entity-action-menu/workspace-entity-action-menu.element.d.ts

@@ -5,7 +5,7 @@ export declare class UmbWorkspaceEntityActionMenuElement extends UmbLitElement {
     private _unique?;
     private _entityType?;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 declare global {

package/dist-cms/packages/core/workspace/components/workspace-split-view/workspace-split-view-variant-selector.element.d.ts

@@ -1,9 +1,16 @@
-import { nothing } from '../../../../../external/lit/index.js';
+import type { UmbVariantDatasetWorkspaceContext } from '../../contexts/index.js';
+import { nothing, type TemplateResult } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../lit-element/index.js';
-import type { UmbEntityVariantModel, UmbEntityVariantOptionModel } from '../../../variant/index.js';
+import { UmbVariantId } from '../../../variant/index.js';
+import type { UmbEntityVariantModel, UmbEntityVariantOptionModel, UmbObjectWithVariantProperties } from '../../../variant/index.js';
 export declare class UmbWorkspaceSplitViewVariantSelectorElement<VariantOptionModelType extends UmbEntityVariantOptionModel<UmbEntityVariantModel> = UmbEntityVariantOptionModel<UmbEntityVariantModel>> extends UmbLitElement {
     #private;
     private _popoverElement?;
+    /**
+     * Variants the workspace holds value data for, regardless of whether a variant has been created for them yet.
+     * Populated by subclasses that know how to source value data; left `undefined` otherwise.
+     */
+    protected _variantsWithData?: Array<UmbVariantId>;
     private _variantOptions;
     private _cultureVariantOptions;
     private _activeVariants;
@@ -12,6 +19,7 @@ export declare class UmbWorkspaceSplitViewVariantSelectorElement<VariantOptionMo
     private _variantId?;
     private _variantSelectorOpen;
     private _readOnlyCultures;
+    private _nameReadOnlyCultures;
     private _variesByCulture;
     private _variesBySegment;
     private _expandedVariants;
@@ -26,8 +34,21 @@ export declare class UmbWorkspaceSplitViewVariantSelectorElement<VariantOptionMo
     protected _variantSorter: (a: VariantOptionModelType, b: VariantOptionModelType) => number;
     constructor();
     private _hintMap;
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
-    protected _renderVariantDetails(variantOption: VariantOptionModelType): import("lit-html").TemplateResult<1>;
+    /**
+     * Checks whether the workspace holds value data for a given segment of a given culture.
+     * A property that varies by segment but not by culture stores its values without a culture,
+     * so a culture-invariant entry counts as data for every culture.
+     * @param {UmbObjectWithVariantProperties} variant - The culture and segment to look for.
+     * @returns {boolean} True if the data holds a value for that culture and segment.
+     */
+    protected _hasDataForSegment(variant: UmbObjectWithVariantProperties): boolean;
+    render(): typeof nothing | TemplateResult<1>;
+    protected _renderVariantDetails(variantOption: VariantOptionModelType): TemplateResult | typeof nothing;
+    /**
+     * Extension point for reacting to when the workspsace context has been set.
+     * @param {UmbVariantDatasetWorkspaceContext | undefined} [workspaceContext] - workspace context
+     */
+    protected _gotWorkspaceContext(workspaceContext?: UmbVariantDatasetWorkspaceContext): void;
     static styles: import("lit").CSSResult[];
 }
 declare global {