@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/content/content-type/structure/content-type-structure-manager.class.js

@@ -1,4 +1,5 @@
 import { UmbRepositoryDetailsManager, } from '../../../core/repository/index.js';
+import { UmbDataTypeDetailRepository } from '../../../data-type/index.js';
 import { UmbId } from '../../../core/id/index.js';
 import { UmbArrayState, partialUpdateFrozenArray, appendToFrozenArray, filterFrozenArray, createObservablePart, observationAsPromise, mergeObservables, } from '../../../../libs/observable-api/index.js';
 import { incrementString } from '../../../core/utils/index.js';
@@ -32,6 +33,9 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     #ownerContentTypeUnique;
     #contentTypeObservers;
     #contentTypes;
+    // Data type detail loading for bulk optimization
+    #dataTypeDetailRepository;
+    #dataTypeDetails;
     async getContentTypeCompositions() {
         return await this.observe(this.contentTypeCompositions).asPromise();
     }
@@ -42,6 +46,14 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     async getContentTypeProperties() {
         return await this.observe(this.contentTypeProperties).asPromise();
     }
+    /**
+     * Get an observable for the data type detail of a data type that is in use by this content type structure.
+     * @param {string} dataTypeUnique - The unique identifier of the data type.
+     * @returns {Observable<UmbDataTypeDetailModel | undefined>} An observable that emits the data type detail or undefined.
+     */
+    contentTypeDataTypeDetailOf(dataTypeUnique) {
+        return this.#dataTypeDetails.asObservablePart((details) => details.find((d) => d.unique === dataTypeUnique));
+    }
     containerById(id) {
         return createObservablePart(this.#contentTypeContainers, (x) => x.find((y) => y.id === id));
     }
@@ -62,6 +74,9 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         });
         this.#contentTypeObservers = new Array();
         this.#contentTypes = new UmbArrayState([], (x) => x.unique);
+        // Data type detail loading for bulk optimization
+        this.#dataTypeDetailRepository = new UmbDataTypeDetailRepository(this);
+        this.#dataTypeDetails = new UmbArrayState([], (x) => x.unique);
         this.contentTypes = this.#contentTypes.asObservable();
         this.ownerContentType = this.#contentTypes.asObservablePart((x) => x.find((y) => y.unique === this.#ownerContentTypeUnique));
         this.ownerContentTypeAlias = createObservablePart(this.ownerContentType, (x) => x?.alias);
@@ -165,6 +180,23 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         this.observe(this.contentTypeCompositions, (contentTypeCompositions) => {
             this.#loadContentTypeCompositions(contentTypeCompositions);
         }, null);
+        // Observe data type uniques and bulk load their details.
+        // Uses nested observation: outer watches which data types are needed,
+        // inner subscribes to the store-backed observable for reactivity.
+        this.observe(this.contentTypeDataTypeUniques, async (dataTypeUniques) => {
+            if (dataTypeUniques.length > 0) {
+                const { asObservable } = await this.#dataTypeDetailRepository.requestByUniques(dataTypeUniques);
+                if (asObservable) {
+                    this.observe(asObservable(), (dataTypeDetails) => {
+                        this.#dataTypeDetails.setValue(dataTypeDetails ?? []);
+                    }, 'observeDataTypeDetails');
+                }
+            }
+            else {
+                this.removeUmbControllerByAlias('observeDataTypeDetails');
+                this.#dataTypeDetails.setValue([]);
+            }
+        }, 'observeDataTypeUniques');
     }
     /**
      * loadType will load the ContentType and all inherited and composed ContentTypes.
@@ -173,46 +205,70 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
      * @returns {Promise} - Promise resolved
      */
     async loadType(unique) {
-        if (this.#ownerContentTypeUnique === unique) {
-            // Its the same, but we do not know if its done loading jet, so we will wait for the load promise to finish. [NL]
+        // Check if already loaded (unique matches AND data exists)
+        if (this.#ownerContentTypeUnique === unique && this.getOwnerContentType()) {
             await this.#init;
             return { data: this.getOwnerContentType(), asObservable: () => this.ownerContentType };
         }
         await this.#initRepository;
-        this.clear();
-        this.#ownerContentTypeUnique = unique;
         if (!unique) {
-            this.#initRejection?.(`Content Type structure manager could not load: ${unique}`);
-            this.#initResolver = undefined;
-            this.#initRejection = undefined;
             return Promise.reject(new Error('The unique identifier is missing. A valid unique identifier is required to load the content type.'));
         }
-        this.#repoManager.setUniques([unique]);
-        const observable = this.#repoManager.entryByUnique(unique);
-        const result = await this.observe(observable).asPromise();
-        if (!result) {
-            this.#initRejection?.(`Content Type structure manager could not load: ${unique}`);
-            this.#initResolver = undefined;
-            this.#initRejection = undefined;
+        // Fetch the content type from the repository
+        const { data, error } = await this.#repository.requestByUnique(unique);
+        if (error || !data) {
             return {
-                error: new UmbError(`Content Type structure manager could not load: ${unique}`),
-                asObservable: () => observable,
+                error: error ?? new UmbError(`Content Type structure manager could not load: ${unique}`),
+                asObservable: () => this.ownerContentType,
             };
         }
-        // Awaits that everything is loaded:
+        // Delegate to setType to handle the rest
+        return this.setType(data);
+    }
+    /**
+     * setType will set the ContentType from already-fetched data and load all inherited and composed ContentTypes.
+     * This is useful when the content type has already been fetched (e.g., via bulk fetch) and you want to avoid re-fetching.
+     * @param {T} contentType - The ContentType to set.
+     * @returns {Promise} - Promise resolved when the content type and all compositions are loaded.
+     */
+    async setType(contentType) {
+        const unique = contentType.unique;
+        // Check if already loaded (unique matches AND data exists)
+        if (this.#ownerContentTypeUnique === unique && this.getOwnerContentType()) {
+            await this.#init;
+            return { data: this.getOwnerContentType(), asObservable: () => this.ownerContentType };
+        }
+        await this.#initRepository;
+        // Only clear if this is a different content type (unique might be pre-set via setOwnerContentTypeUnique)
+        if (this.#ownerContentTypeUnique !== unique) {
+            this.clear();
+        }
+        this.#ownerContentTypeUnique = unique;
+        if (!unique) {
+            this.#initRejection?.(`Content Type structure manager could not set type: ${unique}`);
+            this.#initResolver = undefined;
+            this.#initRejection = undefined;
+            return Promise.reject(new Error('The unique identifier is missing. A valid unique identifier is required to set the content type.'));
+        }
+        // Add entry to repo manager FIRST so it has the status before any observations trigger
+        // (when #contentTypes is updated, it triggers contentTypeCompositions observer which calls setUniques on repoManager)
+        this.#repoManager.addEntry(contentType);
+        // Now add the content type to the state
+        this.#contentTypes.appendOne(contentType);
+        // Awaits that everything is loaded (compositions):
         await observationAsPromise(this.contentTypeLoaded, async (loaded) => {
             return loaded === true;
         }).catch(() => {
-            const msg = `Content Type structure manager could not load: ${unique}. Not all Content Types loaded successfully.`;
+            const msg = `Content Type structure manager could not set type: ${unique}. Not all Content Types loaded successfully.`;
             this.#initRejection?.(msg);
             this.#initResolver = undefined;
             this.#initRejection = undefined;
             return Promise.reject(new UmbError(msg));
         });
-        this.#initResolver?.(result);
+        this.#initResolver?.(contentType);
         this.#initResolver = undefined;
         this.#initRejection = undefined;
-        return { data: result, asObservable: () => this.ownerContentType };
+        return { data: contentType, asObservable: () => this.ownerContentType };
     }
     async createScaffold(preset) {
         await this.#initRepository;
@@ -300,6 +356,10 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         const ownerUnique = this.getOwnerContentTypeUnique();
         if (!ownerUnique)
             return;
+        // Only proceed if the owner content type is actually loaded in #contentTypes
+        // This prevents triggering fetches when only the unique is set (via setOwnerContentTypeUnique) but data isn't loaded yet
+        if (!this.getOwnerContentType())
+            return;
         const compositionUniques = contentTypeCompositions?.map((x) => x.contentType.unique) ?? [];
         const newUniques = [ownerUnique, ...compositionUniques];
         this.#contentTypes.filter((x) => newUniques.includes(x.unique));
@@ -318,6 +378,14 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     getOwnerContentTypeUnique() {
         return this.#ownerContentTypeUnique;
     }
+    /**
+     * Sets the owner content type unique identifier without loading data.
+     * This is useful when you need to register the structure synchronously before async initialization.
+     * @param {string} unique - The unique identifier to set.
+     */
+    setOwnerContentTypeUnique(unique) {
+        this.#ownerContentTypeUnique = unique;
+    }
     getVariesByCulture() {
         const ownerContentType = this.getOwnerContentType();
         return ownerContentType?.variesByCulture;
@@ -604,6 +672,10 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         await this.#init;
         return this.getOwnerContentType()?.properties?.find((property) => property.unique === propertyUnique);
     }
+    async getOwnerPropertiesOf(containerId) {
+        await this.#init;
+        return this.getOwnerContentType()?.properties?.filter((property) => containerId ? property.container?.id === containerId : !property.container);
+    }
     async getPropertyStructureByAlias(propertyAlias) {
         await this.#init;
         for (const docType of this.#contentTypes.getValue()) {
@@ -617,7 +689,7 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     hasPropertyStructuresOf(containerId) {
         return this.#contentTypes.asObservablePart((docTypes) => {
             return (docTypes.find((docType) => {
-                return docType.properties?.find((property) => property.container?.id === containerId);
+                return docType.properties?.find((property) => containerId ? property.container?.id === containerId : !property.container);
             }) !== undefined);
         });
     }
@@ -753,10 +825,12 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         this.#contentTypeObservers = [];
         this.#repoManager?.clear();
         this.#contentTypes.setValue([]);
+        this.#dataTypeDetails.setValue([]);
         this.#ownerContentTypeUnique = undefined;
     }
     destroy() {
         this.#contentTypes.destroy();
+        this.#dataTypeDetails.destroy();
         super.destroy();
     }
     #mergedContainers;

package/dist-cms/packages/content/content-type/types.d.ts

@@ -2,6 +2,7 @@ import type { CompositionTypeModel } from '../../core/backend-api/index.js';
 import type { UmbReferenceByUnique } from '../../core/models/index.js';
 export type * from './composition/types.js';
 export type * from './conditions/types.js';
+export type * from './entity-content-type/types.js';
 export type UmbPropertyContainerTypes = 'Group' | 'Tab';
 export interface UmbPropertyTypeContainerModel {
     id: string;
@@ -52,9 +53,7 @@ export interface UmbPropertyTypeScaffoldModel extends Omit<UmbPropertyTypeModel,
     dataType?: UmbPropertyTypeModel['dataType'];
 }
 export interface UmbPropertyTypeModel {
-    dataType: {
-        unique: string;
-    };
+    dataType: UmbReferenceByUnique;
     unique: string;
     container?: {
         id: string;

package/dist-cms/packages/content/content-type/workspace/views/design/content-type-design-editor-group.element.js

@@ -136,6 +136,7 @@ let UmbContentTypeWorkspaceViewEditGroupElement = class UmbContentTypeWorkspaceV
 					<uui-input
 						id="group-name"
 						label=${this.localize.term('contentTypeEditor_group')}
+						data-mark="input:group-name"
 						placeholder=${this.localize.term('placeholders_entername')}
 						.value=${this._group.name}
 						?disabled=${!this._hasOwnerContainer}
@@ -166,6 +167,7 @@ let UmbContentTypeWorkspaceViewEditGroupElement = class UmbContentTypeWorkspaceV
 						<uui-input
 							type="number"
 							label=${this.localize.term('sort_sortOrder')}
+							data-mark="input:sort-order"
 							.value=${this.group.sortOrder.toString()}
 							?disabled=${!this._hasOwnerContainer}
 							@change=${(e) => this.#singleValueUpdate('sortOrder', parseInt(e.target.value) ?? 0)}></uui-input>

package/dist-cms/packages/content/content-type/workspace/views/design/content-type-design-editor-property.element.js

@@ -126,7 +126,7 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
             return html `
 				<div id="header">
 					<p>${this.localize.string(this.property.name)}<i>${this.property.alias}</i></p>
-					<p>${this.property.description}</p>
+					<p>${this.property.description ?? ''}</p>
 				</div>
 				<div id="editor">
 					${this.#renderPropertyName()} ${this.#renderPropertyTags()}
@@ -172,9 +172,10 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 						<uui-textarea
 							label="description"
 							name="description"
+							data-mark="input:description"
 							id="description-input"
 							placeholder=${this.localize.term('placeholders_enterDescription')}
-							.value=${this.property.description}
+							.value=${this.property.description ?? ''}
 							@input=${(e) => {
                 if (e.target)
                     this.#singleValueUpdate('description', e.target.value);
@@ -186,11 +187,12 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 					id="editor"
 					look="outline"
 					label=${this.localize.term('contentTypeEditor_editorSettings')}
+					data-mark="action:editor-settings"
 					href=${this.editPropertyTypePath +
                 UMB_EDIT_PROPERTY_TYPE_WORKSPACE_PATH_PATTERN.generateLocal({ unique: this.property.unique })}>
 					${this.#renderPropertyName()} ${this.#renderPropertyTags()}
 					<uui-action-bar>
-						<uui-button label="${this.localize.term('actions_delete')}" @click="${this.#requestRemove}">
+						<uui-button label="${this.localize.term('actions_delete')}" data-mark="action:delete" @click="${this.#requestRemove}">
 							<uui-icon name="delete"></uui-icon>
 						</uui-button>
 					</uui-action-bar>
@@ -212,6 +214,7 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 				type="number"
 				?disabled=${this._inherited}
 				label="sort order"
+				data-mark="input:sort-order"
 				@change=${this.#onPropertyOrderChanged}
 				.value=${(this.property.sortOrder ?? 0).toString()}></uui-input>
 		`;
@@ -293,14 +296,19 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 				container-type: inline-size;
 			}
 
-			:host > div {
+			:host > * {
 				grid-column: span 2;
 			}
 
 			@container (width > 700px) {
-				:host(:not([orientation='vertical'])) > div {
+				:host(:not([orientation='vertical'])) > * {
 					grid-column: span 1;
 				}
+				#header {
+					position: sticky;
+					top: var(--uui-size-space-4);
+					height: min-content;
+				}
 			}
 
 			:host(:first-of-type) {
@@ -362,12 +370,6 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 				margin-bottom: 0;
 			}
 
-			#header {
-				position: sticky;
-				top: var(--uui-size-space-4);
-				height: min-content;
-			}
-
 			#header i {
 				opacity: 0.55;
 				float: right;
@@ -387,6 +389,7 @@ let UmbContentTypeDesignEditorPropertyElement = class UmbContentTypeDesignEditor
 
 			#editor {
 				position: relative;
+				min-height: 80px;
 				--uui-button-background-color: var(--uui-color-background);
 				--uui-button-background-color-hover: var(--uui-color-background);
 			}

package/dist-cms/packages/content/content-type/workspace/views/design/content-type-design-editor-tab.element.js

@@ -223,6 +223,7 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
 			<uui-button
 				id="btn-add"
 				label=${this.localize.term('contentTypeEditor_addGroup')}
+				data-mark="action:add-group"
 				look="placeholder"
 				@click=${this.#onAddGroup}></uui-button>
 		`;

package/dist-cms/packages/content/property-type/workspace/views/settings/property-workspace-view-settings.element.js

@@ -166,7 +166,7 @@ let UmbPropertyTypeWorkspaceViewSettingsElement = class UmbPropertyTypeWorkspace
 						slot="editor"
 						name="description"
 						@input=${this.#onDescriptionChange}
-						.value=${this._data?.description}
+						.value=${this._data?.description ?? ''}
 						auto-height></uui-textarea>
 				</umb-property-layout>
 

package/dist-cms/packages/core/audit-log/audit-log-repository.interface.d.ts

@@ -1,5 +1,6 @@
-import type { UmbAuditLogModel, UmbAuditLogRequestArgs } from './types.js';
+import type { UmbAuditLogModel, UmbAuditLogRequestArgs, UmbAuditLogTagData } from './types.js';
 import type { UmbPagedModel, UmbRepositoryBase, UmbRepositoryResponse } from '../repository/index.js';
-export interface UmbAuditLogRepository<AuditLogType extends UmbAuditLogModel<any>> extends UmbRepositoryBase {
+export interface UmbAuditLogRepository<AuditLogType extends UmbAuditLogModel<any> = UmbAuditLogModel> extends UmbRepositoryBase {
     requestAuditLog(args: UmbAuditLogRequestArgs): Promise<UmbRepositoryResponse<UmbPagedModel<AuditLogType>>>;
+    getTagStyleAndText?(logType: string): UmbAuditLogTagData;
 }

package/dist-cms/packages/core/audit-log/index.d.ts

@@ -1,4 +1,4 @@
 export type { UmbAuditLogRepository } from './audit-log-repository.interface.js';
 export type { UmbAuditLogDataSource } from './audit-log-data-source.interface.js';
-export type { UmbAuditLogModel, UmbAuditLogRequestArgs } from './types.js';
+export type { UmbAuditLogModel, UmbAuditLogRequestArgs, UmbAuditLogTagData, UmbAuditLogTagLocalizeKeys, UmbAuditLogTagStyleMap } from './types.js';
 export type { UmbAuditLogType } from './utils.js';

package/dist-cms/packages/core/audit-log/types.d.ts

@@ -14,3 +14,15 @@ export interface UmbAuditLogRequestArgs {
     skip?: number;
     take?: number;
 }
+export interface UmbAuditLogTagStyleMap {
+    look: 'default' | 'primary' | 'secondary' | 'outline' | 'placeholder';
+    color: 'default' | 'danger' | 'warning' | 'positive';
+}
+export interface UmbAuditLogTagLocalizeKeys {
+    label: string;
+    desc: string;
+}
+export interface UmbAuditLogTagData {
+    style: UmbAuditLogTagStyleMap;
+    text: UmbAuditLogTagLocalizeKeys;
+}

package/dist-cms/packages/core/auth/auth.context.d.ts

@@ -1,11 +1,20 @@
+import type { UmbTokenEndpointResponse } from './umb-auth-client.js';
 import type { UmbOpenApiConfiguration } from './models/openApiConfiguration.js';
 import type { ManifestAuthProvider } from './auth-provider.extension.js';
 import type { UmbControllerHost } from '../../../libs/controller-api/index.js';
 import { UmbContextBase } from '../../../libs/class-api/index.js';
 import type { Observable } from '../../../external/rxjs/index.js';
 import type { UmbBackofficeExtensionRegistry } from '../extension-registry/index.js';
+import type { umbHttpClient } from '../http-client/index.js';
+export interface UmbAuthSession {
+    /** When the access token expires (issuedAt + expiresIn). Used to decide when to refresh. */
+    accessTokenExpiresAt: number;
+    /** When the full session expires (issuedAt + expiresIn * MULTIPLIER). Used for timeout UI. */
+    expiresAt: number;
+}
 export declare class UmbAuthContext extends UmbContextBase {
     #private;
+    readonly session$: Observable<UmbAuthSession | undefined>;
     /**
      * Observable that emits true when the auth context is initialized.
      * @remark It will only emit once and then complete itself.
@@ -24,11 +33,17 @@ export declare class UmbAuthContext extends UmbContextBase {
     readonly timeoutSignal: Observable<void>;
     /**
      * Observable that acts as a signal for when the authorization state changes.
+     * @deprecated Observe isAuthorized instead. Scheduled for removal in Umbraco 19.
      * @remark It will emit once per second, so it can be used to trigger UI updates or other actions when the authorization state changes.
-     * @returns {Subject<void>} An observable that emits when the authorization state changes.
+     * @returns An observable that emits when the authorization state changes.
      */
     get authorizationSignal(): Observable<void>;
-    constructor(host: UmbControllerHost, serverUrl: string, backofficePath: string, isBypassed: boolean);
+    /**
+     * Whether the server is configured to keep users logged in by auto-refreshing before session expiry.
+     * Provided by the backend via the `keep-user-logged-in` attribute on `<umb-app>`.
+     */
+    readonly keepUserLoggedIn: boolean;
+    constructor(host: UmbControllerHost, serverUrl: string, backofficePath: string, isBypassed: boolean, keepUserLoggedIn?: boolean);
     destroy(): void;
     /**
      * Initiates the login flow.
@@ -40,8 +55,10 @@ export declare class UmbAuthContext extends UmbContextBase {
     makeAuthorizationRequest(identityProvider?: string, redirect?: boolean, usernameHint?: string, manifest?: ManifestAuthProvider): Promise<void>;
     /**
      * Completes the login flow.
+     * This is called on the oauth_complete page to exchange the authorization code for tokens.
+     * @returns The token response timing, or null if no authorization was pending.
      */
-    completeAuthorizationRequest(): Promise<import("../../../external/openid/index.js").AuthorizationRequestResponse | null>;
+    completeAuthorizationRequest(): Promise<UmbTokenEndpointResponse | null>;
     /**
      * Checks if the user is authorized. If Authorization is bypassed, the user is always authorized.
      * @returns True if the user is authorized, otherwise false.
@@ -49,34 +66,53 @@ export declare class UmbAuthContext extends UmbContextBase {
     getIsAuthorized(): boolean;
     /**
      * Sets the initial state of the auth flow.
+     * First asks existing tabs for their session via BroadcastChannel.
+     * If no peer responds, falls back to a server refresh.
      * @returns {Promise<void>}
      */
     setInitialState(): Promise<void>;
     /**
      * Gets the latest token from the Management API.
-     * If the token is expired, it will be refreshed.
+     * With cookie auth, this returns '[redacted]' — the real token is in the httpOnly cookie.
+     * If the session has expired, it will attempt a refresh first.
      *
-     * NB! The user may experience being redirected to the login screen if the token is expired.
      * @example <caption>Using the latest token</caption>
      * ```js
      *   const token = await authContext.getLatestToken();
      *   const result = await fetch('https://my-api.com', { headers: { Authorization: `Bearer ${token}` } });
      * ```
+     * @deprecated Use {@link configureClient} for `@hey-api/openapi-ts` clients or {@link getOpenApiConfiguration} for manual fetch calls. With cookie-based auth this always returns `'[redacted]'`. Scheduled for removal in Umbraco 19.
+     * @see {@link configureClient} for automatic token handling with `@hey-api/openapi-ts` clients.
+     * @see {@link getOpenApiConfiguration} for manual fetch calls with cookie-based auth.
      * @memberof UmbAuthContext
      * @returns The latest token from the Management API
      */
     getLatestToken(): Promise<string>;
     /**
-     * Validates the token against the server and returns true if the token is valid.
+     * Forces a token refresh against the server (calls `/token`) and returns true if successful.
+     * Use this when you need to unconditionally refresh — e.g. session timeout keep-alive.
+     * For per-request token handling, prefer {@link configureClient} which skips the network
+     * call when the access token is still valid.
+     * Uses Web Locks to deduplicate concurrent refresh requests across tabs.
      * @memberof UmbAuthContext
-     * @returns True if the token is valid, otherwise false
+     * @returns True if the refresh succeeded, otherwise false
      */
     validateToken(): Promise<boolean>;
     /**
-     * Clears the token storage.
+     * Attempts to refresh the token using Web Locks to prevent concurrent refresh requests.
+     * @returns True if the refresh was successful, otherwise false.
+     */
+    makeRefreshTokenRequest(): Promise<boolean>;
+    /**
+     * Checks if the current session is still valid.
+     * @returns True if the session has not expired.
+     */
+    isSessionValid(): boolean;
+    /**
+     * Clears the in-memory session state.
      * @memberof UmbAuthContext
      */
-    clearTokenStorage(): Promise<void>;
+    clearTokenStorage(): void;
     /**
      * Handles the case where the user has timed out, i.e. the token has expired.
      * This will clear the token storage and set the user as unauthorized.
@@ -84,7 +120,7 @@ export declare class UmbAuthContext extends UmbContextBase {
      */
     timeOut(): void;
     /**
-     * Signs the user out by removing any tokens from the browser.
+     * Signs the user out by revoking tokens and redirecting to the end session endpoint.
      * @memberof UmbAuthContext
      */
     signOut(): Promise<void>;
@@ -98,9 +134,11 @@ export declare class UmbAuthContext extends UmbContextBase {
      * ```
      * @example <caption></caption>
      * ```js
-     * 	const serverUrl = authContext.getServerUrl();
-     * 	const token = await authContext.getLatestToken();
-     * 	const result = await fetch(`${serverUrl}/umbraco/management/api/v1/my-resource`, { headers: { Authorization: `Bearer ${token}` } });
+     * 	const config = authContext.getOpenApiConfiguration();
+     * 	const result = await fetch(`${config.base}/umbraco/management/api/v1/my-resource`, {
+     * 		credentials: config.credentials,
+     * 		headers: { Authorization: `Bearer ${await config.token()}` },
+     * 	});
      * ```
      * @returns The server url to the Management API
      */
@@ -120,6 +158,19 @@ export declare class UmbAuthContext extends UmbContextBase {
      * @returns {UmbOpenApiConfiguration} The default OpenAPI configuration
      */
     getOpenApiConfiguration(): UmbOpenApiConfiguration;
+    /**
+     * Configures a `@hey-api/openapi-ts` client for authenticated API calls.
+     * Sets baseUrl, credentials, auth header, and binds the default response
+     * interceptors (401 retry, error handling, notifications).
+     * @example
+     * ```js
+     * const authContext = await this.getContext(UMB_AUTH_CONTEXT);
+     * authContext.configureClient(myClient);
+     * // Now myClient automatically includes auth headers and interceptors
+     * ```
+     * @param client A `@hey-api/openapi-ts` client instance.
+     */
+    configureClient(client: typeof umbHttpClient): void;
     /**
      * Sets the auth context as initialized, which means that the auth context is ready to be used.
      * @remark This is used to let the app context know that the core module is ready, which means that the core auth providers are available.
@@ -141,14 +192,14 @@ export declare class UmbAuthContext extends UmbContextBase {
      */
     getPostLogoutRedirectUrl(): string;
     /**
-     * @param provider
-     * @see UmbAuthFlow#linkLogin
+     * Links the current user to the specified provider by redirecting to the link endpoint.
+     * @param provider The provider to link to.
      */
     linkLogin(provider: string): Promise<void>;
     /**
-     * @param providerName
+     * Unlinks the current user from the specified provider.
+     * @param loginProvider
      * @param providerKey
-     * @see UmbAuthFlow#unlinkLogin
      */
-    unlinkLogin(providerName: string, providerKey: string): Promise<boolean>;
+    unlinkLogin(loginProvider: string, providerKey: string): Promise<boolean>;
 }