@umbraco-cms/backoffice 16.3.3 → 16.4.0-rc

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

@@ -6,22 +6,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { UMB_CONTENT_TYPE_WORKSPACE_CONTEXT } from '../../content-type-workspace.context-token.js';
 import { UmbContentTypeContainerStructureHelper } from '../../../structure/index.js';
-import { UMB_CONTENT_TYPE_DESIGN_EDITOR_CONTEXT } from './content-type-design-editor.context-token.js';
 import { css, customElement, html, nothing, property, repeat, state } from '../../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../../core/lit-element/index.js';
+import { UMB_CONTENT_TYPE_DESIGN_EDITOR_CONTEXT } from './content-type-design-editor.context-token.js';
 import { UmbModalRouteRegistrationController } from '../../../../../core/router/index.js';
 import { UmbSorterController } from '../../../../../core/sorter/index.js';
 import { UMB_WORKSPACE_MODAL } from '../../../../../core/workspace/index.js';
 import './content-type-design-editor-properties.element.js';
 import './content-type-design-editor-group.element.js';
 const SORTER_CONFIG = {
-    getUniqueOfElement: (element) => element.group?.key,
-    getUniqueOfModel: (modelEntry) => modelEntry.key,
+    getUniqueOfElement: (element) => element.group?.ownerId ?? element.group?.ids[0],
+    getUniqueOfModel: (modelEntry) => modelEntry.ownerId ?? modelEntry.ids[0],
     // TODO: Make specific to the current owner document. [NL]
     identifier: 'content-type-container-sorter',
     itemSelector: 'umb-content-type-design-editor-group',
     handleSelector: '.drag-handle',
-    disabledItemSelector: '[inherited]', // Inherited attribute is set by the umb-content-type-design-editor-group.
+    disabledItemSelector: ':not([has-owner-container])', // Inherited attribute is set by the umb-content-type-design-editor-group.
     containerSelector: '.container-list',
 };
 let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabElement extends UmbLitElement {
@@ -40,6 +40,7 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
         this.requestUpdate('containerId', oldValue);
     }
     #groupStructureHelper;
+    #contentTypeWorkspaceContext;
     constructor() {
         super();
         this.#sorter = new UmbSorterController(this, {
@@ -47,18 +48,30 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
             onChange: ({ model }) => {
                 this._groups = model;
             },
+            onContainerChange: ({ item }) => {
+                if (this.#containerId === undefined) {
+                    throw new Error('ContainerId is not set');
+                }
+                if (item.ownerId === undefined) {
+                    // This may be possible later, but for now this is not possible. [NL]
+                    throw new Error('OwnerId is not set for the given container, we cannot move containers that are not owned by the current Document.');
+                }
+                this.#groupStructureHelper.partialUpdateContainer(item.ownerId, {
+                    parent: this.#containerId ? { id: this.#containerId } : null,
+                });
+            },
             onEnd: ({ item }) => {
-                /*if (this._inherited === undefined) {
-                throw new Error('OwnerTabId is not set, we have not made a local duplicated of this container.');
-                return;
-            }*/
+                if (item.ownerId === undefined) {
+                    // This may be possible later, but for now this is not possible. [NL]
+                    throw new Error('OwnerId is not set for the given container, we cannot move containers that are not owned by the current Document.');
+                }
                 /**
                  * Explanation: If the item is the first in list, we compare it to the item behind it to set a sortOrder.
                  * If it's not the first in list, we will compare to the item in before it, and check the following item to see if it caused overlapping sortOrder, then update
                  * the overlap if true, which may cause another overlap, so we loop through them till no more overlaps...
                  */
                 const model = this._groups;
-                const newIndex = model.findIndex((entry) => entry.key === item.key);
+                const newIndex = model.findIndex((entry) => entry.ownerId === item.ownerId);
                 // Doesn't exist in model
                 if (newIndex === -1)
                     return;
@@ -88,26 +101,27 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
                         this.#groupStructureHelper.partialUpdateContainer(entry.ownerId, {
                             sortOrder: ++prevSortOrder,
                         });
-                        i++;
                     }
+                    i++;
                 }
             },
             onRequestDrop: async ({ unique }) => {
-                const context = await this.getContext(UMB_CONTENT_TYPE_WORKSPACE_CONTEXT);
+                const context = this.#contentTypeWorkspaceContext;
                 if (!context) {
                     throw new Error('Could not get Workspace Context');
                 }
-                return context.structure.getMergedContainerById(unique);
+                const result = context.structure.getMergedContainerById(unique);
+                return result;
             },
             requestExternalRemove: async ({ item }) => {
-                const context = await this.getContext(UMB_CONTENT_TYPE_WORKSPACE_CONTEXT);
+                const context = this.#contentTypeWorkspaceContext;
                 if (!context) {
                     throw new Error('Could not get Workspace Context');
                 }
                 return await context.structure.removeContainer(null, item.ownerId, { preventRemovingProperties: true }).then(() => true, () => false);
             },
             requestExternalInsert: async ({ item }) => {
-                const context = await this.getContext(UMB_CONTENT_TYPE_WORKSPACE_CONTEXT);
+                const context = this.#contentTypeWorkspaceContext;
                 if (!context) {
                     throw new Error('Could not get Workspace Context');
                 }
@@ -136,6 +150,7 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
             this.#groupStructureHelper.addContainer(this.#containerId, sortOrder);
         };
         this.consumeContext(UMB_CONTENT_TYPE_WORKSPACE_CONTEXT, (context) => {
+            this.#contentTypeWorkspaceContext = context;
             this.#groupStructureHelper.setStructureManager(context?.structure);
             const entityType = context?.getEntityType();
             this.#workspaceModal?.destroy();
@@ -151,12 +166,6 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
         this.consumeContext(UMB_CONTENT_TYPE_DESIGN_EDITOR_CONTEXT, (context) => {
             this.observe(context?.isSorting, (isSorting) => {
                 this._sortModeActive = isSorting;
-                if (isSorting) {
-                    this.#sorter.enable();
-                }
-                else {
-                    this.#sorter.disable();
-                }
             }, '_observeIsSorting');
         });
         this.observe(this.#groupStructureHelper.childContainers, (groups) => {
@@ -230,10 +239,20 @@ let UmbContentTypeDesignEditorTabElement = class UmbContentTypeDesignEditorTabEl
 				align-content: start;
 			}
 
+			/* Ensure the container-list has some height when its empty so groups can be dropped into it.*/
+			.container-list {
+				margin-top: calc(var(--uui-size-layout-1) * -1);
+				padding-top: var(--uui-size-layout-1);
+			}
+
 			.container-list #convert-to-tab {
 				margin-bottom: var(--uui-size-layout-1);
 				display: flex;
 			}
+
+			.container-list[sort-mode-active] {
+				min-height: 100px;
+			}
 		`,
     ]; }
 };

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

@@ -636,7 +636,7 @@ let UmbContentTypeDesignEditorElement = class UmbContentTypeDesignEditorElement
 				transition: opacity 100ms;
 			}
 
-			uui-tab:not(:hover, :focus) .trash {
+			uui-tab:not(:hover, :focus, :focus-within) .trash {
 				opacity: 0;
 				transition: opacity 100ms;
 			}

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

@@ -67,7 +67,7 @@ let UmbPropertyTypeWorkspaceViewSettingsElement = class UmbPropertyTypeWorkspace
     }
     #onAliasChange() {
         // TODO: Why can I not get the correct value via event? Is it an issue in uui library too?
-        const alias = generateAlias(this._aliasInput.value.toString());
+        const alias = this._aliasInput.value.toString();
         this.updateValue({ alias });
     }
     #onDescriptionChange(event) {

package/dist-cms/packages/core/auth/auth-flow.js

@@ -198,6 +198,9 @@ export class UmbAuthFlow {
         await this.#storageBackend.removeItem(UMB_STORAGE_TOKEN_RESPONSE_NAME);
         // clear the internal state
         this.#tokenResponse.setValue(undefined);
+        // Also cleanup any OAuth/PKCE artifacts that may still be in localStorage
+        // This is a defense-in-depth measure during logout
+        await this.#authorizationHandler.cleanupStaleAuthorizationData();
     }
     /**
      * This method will sign the user out of the application.

package/dist-cms/packages/core/backend-api/client/client.gen.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 import { createSseClient } from '../core/serverSentEvents.gen.js';
+import { getValidRequestBody } from '../core/utils.gen.js';
 import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen.js';
 export const createClient = (config = {}) => {
     let _config = mergeConfigs(createConfig(), config);
@@ -26,11 +27,11 @@ export const createClient = (config = {}) => {
         if (opts.requestValidator) {
             await opts.requestValidator(opts);
         }
-        if (opts.body && opts.bodySerializer) {
+        if (opts.body !== undefined && opts.bodySerializer) {
             opts.serializedBody = opts.bodySerializer(opts.body);
         }
         // remove Content-Type header if body is empty to avoid sending invalid requests
-        if (opts.serializedBody === undefined || opts.serializedBody === '') {
+        if (opts.body === undefined || opts.serializedBody === '') {
             opts.headers.delete('Content-Type');
         }
         const url = buildUrl(opts);
@@ -42,10 +43,10 @@ export const createClient = (config = {}) => {
         const requestInit = {
             redirect: 'follow',
             ...opts,
-            body: opts.serializedBody,
+            body: getValidRequestBody(opts),
         };
         let request = new Request(url, requestInit);
-        for (const fn of interceptors.request._fns) {
+        for (const fn of interceptors.request.fns) {
             if (fn) {
                 request = await fn(request, opts);
             }
@@ -54,7 +55,7 @@ export const createClient = (config = {}) => {
         // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
         const _fetch = opts.fetch;
         let response = await _fetch(request);
-        for (const fn of interceptors.response._fns) {
+        for (const fn of interceptors.response.fns) {
             if (fn) {
                 response = await fn(response, request, opts);
             }
@@ -64,18 +65,36 @@ export const createClient = (config = {}) => {
             response,
         };
         if (response.ok) {
+            const parseAs = (opts.parseAs === 'auto'
+                ? getParseAs(response.headers.get('Content-Type'))
+                : opts.parseAs) ?? 'json';
             if (response.status === 204 ||
                 response.headers.get('Content-Length') === '0') {
+                let emptyData;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'text':
+                        emptyData = await response[parseAs]();
+                        break;
+                    case 'formData':
+                        emptyData = new FormData();
+                        break;
+                    case 'stream':
+                        emptyData = response.body;
+                        break;
+                    case 'json':
+                    default:
+                        emptyData = {};
+                        break;
+                }
                 return opts.responseStyle === 'data'
-                    ? {}
+                    ? emptyData
                     : {
-                        data: {},
+                        data: emptyData,
                         ...result,
                     };
             }
-            const parseAs = (opts.parseAs === 'auto'
-                ? getParseAs(response.headers.get('Content-Type'))
-                : opts.parseAs) ?? 'json';
             let data;
             switch (parseAs) {
                 case 'arrayBuffer':
@@ -118,7 +137,7 @@ export const createClient = (config = {}) => {
         }
         const error = jsonError ?? textError;
         let finalError = error;
-        for (const fn of interceptors.error._fns) {
+        for (const fn of interceptors.error.fns) {
             if (fn) {
                 finalError = (await fn(error, response, request, opts));
             }
@@ -143,6 +162,15 @@ export const createClient = (config = {}) => {
             body: opts.body,
             headers: opts.headers,
             method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
             url,
         });
     };

package/dist-cms/packages/core/backend-api/client/index.d.ts

@@ -2,6 +2,7 @@ export type { Auth } from '../core/auth.gen.js';
 export type { QuerySerializerOptions } from '../core/bodySerializer.gen.js';
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen.js';
 export { buildClientParams } from '../core/params.gen.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
 export { createClient } from './client.gen.js';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, OptionsLegacyParser, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen.js';
 export { createConfig, mergeHeaders } from './utils.gen.js';

package/dist-cms/packages/core/backend-api/client/index.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen.js';
 export { buildClientParams } from '../core/params.gen.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
 export { createClient } from './client.gen.js';
 export { createConfig, mergeHeaders } from './utils.gen.js';

package/dist-cms/packages/core/backend-api/client/types.gen.d.ts

@@ -14,7 +14,7 @@ export interface Config<T extends ClientOptions = ClientOptions> extends Omit<Re
      *
      * @default globalThis.fetch
      */
-    fetch?: (request: Request) => ReturnType<typeof fetch>;
+    fetch?: typeof fetch;
     /**
      * Please don't use the Fetch client for Next.js applications. The `next`
      * options won't have any effect.

package/dist-cms/packages/core/backend-api/client/utils.gen.d.ts

@@ -15,24 +15,19 @@ type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, reques
 type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {
-    _fns: (Interceptor | null)[];
-    constructor();
+    fns: Array<Interceptor | null>;
     clear(): void;
-    getInterceptorIndex(id: number | Interceptor): number;
-    exists(id: number | Interceptor): boolean;
     eject(id: number | Interceptor): void;
-    update(id: number | Interceptor, fn: Interceptor): number | false | Interceptor;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
     use(fn: Interceptor): number;
 }
 export interface Middleware<Req, Res, Err, Options> {
-    error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, 'eject' | 'use'>;
-    request: Pick<Interceptors<ReqInterceptor<Req, Options>>, 'eject' | 'use'>;
-    response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, 'eject' | 'use'>;
-}
-export declare const createInterceptors: <Req, Res, Err, Options>() => {
     error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
     request: Interceptors<ReqInterceptor<Req, Options>>;
     response: Interceptors<ResInterceptor<Res, Req, Options>>;
-};
+}
+export declare const createInterceptors: <Req, Res, Err, Options>() => Middleware<Req, Res, Err, Options>;
 export declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
 export {};

package/dist-cms/packages/core/backend-api/client/utils.gen.js

@@ -134,13 +134,22 @@ export const mergeConfigs = (a, b) => {
     config.headers = mergeHeaders(a.headers, b.headers);
     return config;
 };
+const headersEntries = (headers) => {
+    const entries = [];
+    headers.forEach((value, key) => {
+        entries.push([key, value]);
+    });
+    return entries;
+};
 export const mergeHeaders = (...headers) => {
     const mergedHeaders = new Headers();
     for (const header of headers) {
-        if (!header || typeof header !== 'object') {
+        if (!header) {
             continue;
         }
-        const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
+        const iterator = header instanceof Headers
+            ? headersEntries(header)
+            : Object.entries(header);
         for (const [key, value] of iterator) {
             if (value === null) {
                 mergedHeaders.delete(key);
@@ -161,45 +170,40 @@ export const mergeHeaders = (...headers) => {
 };
 class Interceptors {
     constructor() {
-        this._fns = [];
+        this.fns = [];
     }
     clear() {
-        this._fns = [];
+        this.fns = [];
     }
-    getInterceptorIndex(id) {
-        if (typeof id === 'number') {
-            return this._fns[id] ? id : -1;
-        }
-        else {
-            return this._fns.indexOf(id);
+    eject(id) {
+        const index = this.getInterceptorIndex(id);
+        if (this.fns[index]) {
+            this.fns[index] = null;
         }
     }
     exists(id) {
         const index = this.getInterceptorIndex(id);
-        return !!this._fns[index];
+        return Boolean(this.fns[index]);
     }
-    eject(id) {
-        const index = this.getInterceptorIndex(id);
-        if (this._fns[index]) {
-            this._fns[index] = null;
+    getInterceptorIndex(id) {
+        if (typeof id === 'number') {
+            return this.fns[id] ? id : -1;
         }
+        return this.fns.indexOf(id);
     }
     update(id, fn) {
         const index = this.getInterceptorIndex(id);
-        if (this._fns[index]) {
-            this._fns[index] = fn;
+        if (this.fns[index]) {
+            this.fns[index] = fn;
             return id;
         }
-        else {
-            return false;
-        }
+        return false;
     }
     use(fn) {
-        this._fns = [...this._fns, fn];
-        return this._fns.length - 1;
+        this.fns.push(fn);
+        return this.fns.length - 1;
     }
 }
-// do not add `Middleware` as return type so we can use _fns internally
 export const createInterceptors = () => ({
     error: new Interceptors(),
     request: new Interceptors(),

package/dist-cms/packages/core/backend-api/client.gen.d.ts

@@ -1,5 +1,5 @@
-import type { ClientOptions } from './types.gen.js';
-import { type Config, type ClientOptions as DefaultClientOptions } from './client/index.js';
+import { type ClientOptions, type Config } from './client/index.js';
+import type { ClientOptions as ClientOptions2 } from './types.gen.js';
 /**
  * The `createClientConfig()` function will be called on client initialization
  * and the returned object will become the client's initial configuration.
@@ -8,5 +8,5 @@ import { type Config, type ClientOptions as DefaultClientOptions } from './clien
  * `setConfig()`. This is useful for example if you're using Next.js
  * to ensure your client always has the correct values.
  */
-export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
 export declare const client: import("./client/index.js").Client;

package/dist-cms/packages/core/backend-api/core/queryKeySerializer.gen.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JSON-friendly union that mirrors what Pinia Colada can hash.
+ */
+export type JsonValue = null | string | number | boolean | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
+ */
+export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => {} | null | undefined;
+/**
+ * Safely stringifies a value and parses it back into a JsonValue.
+ */
+export declare const stringifyToJsonValue: (input: unknown) => JsonValue | undefined;
+/**
+ * Normalizes any accepted value into a JSON-friendly shape for query keys.
+ */
+export declare const serializeQueryKeyValue: (value: unknown) => JsonValue | undefined;

package/dist-cms/packages/core/backend-api/core/queryKeySerializer.gen.js

@@ -0,0 +1,99 @@
+// This file is auto-generated by @hey-api/openapi-ts
+/**
+ * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
+ */
+export const queryKeyJsonReplacer = (_key, value) => {
+    if (value === undefined ||
+        typeof value === 'function' ||
+        typeof value === 'symbol') {
+        return undefined;
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return value;
+};
+/**
+ * Safely stringifies a value and parses it back into a JsonValue.
+ */
+export const stringifyToJsonValue = (input) => {
+    try {
+        const json = JSON.stringify(input, queryKeyJsonReplacer);
+        if (json === undefined) {
+            return undefined;
+        }
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Detects plain objects (including objects with a null prototype).
+ */
+const isPlainObject = (value) => {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+/**
+ * Turns URLSearchParams into a sorted JSON object for deterministic keys.
+ */
+const serializeSearchParams = (params) => {
+    const entries = Array.from(params.entries()).sort(([a], [b]) => a.localeCompare(b));
+    const result = {};
+    for (const [key, value] of entries) {
+        const existing = result[key];
+        if (existing === undefined) {
+            result[key] = value;
+            continue;
+        }
+        if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            result[key] = [existing, value];
+        }
+    }
+    return result;
+};
+/**
+ * Normalizes any accepted value into a JSON-friendly shape for query keys.
+ */
+export const serializeQueryKeyValue = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value === undefined ||
+        typeof value === 'function' ||
+        typeof value === 'symbol') {
+        return undefined;
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return stringifyToJsonValue(value);
+    }
+    if (typeof URLSearchParams !== 'undefined' &&
+        value instanceof URLSearchParams) {
+        return serializeSearchParams(value);
+    }
+    if (isPlainObject(value)) {
+        return stringifyToJsonValue(value);
+    }
+    return undefined;
+};

package/dist-cms/packages/core/backend-api/core/serverSentEvents.gen.d.ts

@@ -1,5 +1,16 @@
 import type { Config } from './types.gen.js';
 export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
     /**
      * Callback invoked when a network or parsing error occurs during streaming.
      *
@@ -17,6 +28,7 @@ export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method
      * @returns Nothing (void).
      */
     onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
     /**
      * Default retry delay in milliseconds.
      *
@@ -56,4 +68,4 @@ export interface StreamEvent<TData = unknown> {
 export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-export declare const createSseClient: <TData = unknown>({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;
+export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;

package/dist-cms/packages/core/backend-api/core/serverSentEvents.gen.js

@@ -1,5 +1,5 @@
 // This file is auto-generated by @hey-api/openapi-ts
-export const createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
     let lastEventId;
     const sleep = sseSleepFn ??
         ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -18,7 +18,21 @@ export const createSseClient = ({ onSseError, onSseEvent, responseTransformer, r
                 headers.set('Last-Event-ID', lastEventId);
             }
             try {
-                const response = await fetch(url, { ...options, headers, signal });
+                const requestInit = {
+                    redirect: 'follow',
+                    ...options,
+                    body: options.serializedBody,
+                    headers,
+                    signal,
+                };
+                let request = new Request(url, requestInit);
+                if (onRequest) {
+                    request = await onRequest(url, requestInit);
+                }
+                // fetch must be assigned here, otherwise it would throw the error:
+                // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+                const _fetch = options.fetch ?? globalThis.fetch;
+                const response = await _fetch(request);
                 if (!response.ok)
                     throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
                 if (!response.body)

package/dist-cms/packages/core/backend-api/core/utils.gen.d.ts

@@ -1,4 +1,4 @@
-import type { QuerySerializer } from './bodySerializer.gen.js';
+import type { BodySerializer, QuerySerializer } from './bodySerializer.gen.js';
 export interface PathSerializer {
     path: Record<string, unknown>;
     url: string;
@@ -12,3 +12,8 @@ export declare const getUrl: ({ baseUrl, path, query, querySerializer, url: _url
     querySerializer: QuerySerializer;
     url: string;
 }) => string;
+export declare function getValidRequestBody(options: {
+    body?: unknown;
+    bodySerializer?: BodySerializer | null;
+    serializedBody?: unknown;
+}): unknown;