@sapui5/sap.fe.base 1.143.0 → 1.145.0

package/src/sap/fe/base/jsx-runtime/jsx.js

@@ -17,6 +17,13 @@ sap.ui.define(["sap/fe/base/jsx-runtime/jsx-control", "sap/fe/base/jsx-runtime/j
       return jsxXml(ControlType, mSettings, key, xmlNamespaceMap);
     }
   };
+
+  /**
+   * Indicates that the next JSX call is rendered using the provided RenderManager.
+   * @param renderManager The UI5 RenderManager to use for rendering
+   * @param control The control to render
+   * @param renderMethod The method to be rendered
+   */
   jsx.renderUsingRenderManager = function (renderManager, control, renderMethod) {
     renderNextUsingRenderManager = renderManager;
     const returnValue = renderMethod(control);
@@ -57,6 +64,11 @@ sap.ui.define(["sap/fe/base/jsx-runtime/jsx-control", "sap/fe/base/jsx-runtime/j
     jsxContext = {};
     return callBackReturn;
   };
+
+  /**
+   * JSX support for UI5 controls.
+   * @returns The control or controls created
+   */
   return jsx;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["renderNextAsXML","renderNextUsingRenderManager","xmlNamespaceMap","jsx","ControlType","mSettings","key","jsxControl","jsxContext","jsxFormatterContext","undefined","jsxRenderManager","jsxXml","renderUsingRenderManager","renderManager","control","renderMethod","returnValue","defineXMLNamespaceMap","namespaceMap","renderAsXML","getContext","setFormatterContext","context","getFormatterContext","withContext","functionToExecute","callBackReturn"],"sourceRoot":".","sources":["jsx.ts"],"sourcesContent":["import jsxControl from \"sap/fe/base/jsx-runtime/jsx-control\";\nimport jsxRenderManager from \"sap/fe/base/jsx-runtime/jsx-renderManager\";\nimport jsxXml from \"sap/fe/base/jsx-runtime/jsx-xml\";\nimport type AppComponent from \"sap/fe/core/AppComponent\";\nimport type Control from \"sap/ui/core/Control\";\nimport type Element from \"sap/ui/core/Element\";\nimport type RenderManager from \"sap/ui/core/RenderManager\";\n\nimport type View from \"sap/ui/core/mvc/View\";\n\ntype ControlPropertyNames<T> = {\n\t[K in keyof T]: T[K] extends string | boolean | Function | number | undefined | string[] ? never : K;\n}[keyof T];\nexport type ControlProperties<T> = Partial<Record<ControlPropertyNames<T>, Element>> & {\n\t[k: string]: Element;\n};\nexport type NonControlProperties<T> = Partial<Omit<T, ControlPropertyNames<T>>>;\nexport type CommandProperties = `cmd:${string}|${string}`;\n\nlet renderNextAsXML = false;\nlet renderNextUsingRenderManager: RenderManager | undefined;\nlet xmlNamespaceMap: Record<string, string> = {};\nconst jsx = function <T>(\n\tControlType: typeof Control,\n\tmSettings: NonControlProperties<T> & { key: string; children?: Element | ControlProperties<T> },\n\tkey: string\n): string | Control | Control[] | undefined {\n\tif (!renderNextAsXML && !renderNextUsingRenderManager) {\n\t\treturn jsxControl(ControlType, mSettings, key, jsxContext, jsxFormatterContext);\n\t} else if (renderNextUsingRenderManager !== undefined) {\n\t\treturn jsxRenderManager(\n\t\t\tControlType as unknown as string,\n\t\t\tmSettings as Record<string, string>,\n\t\t\tkey,\n\t\t\trenderNextUsingRenderManager\n\t\t) as unknown as string | Control | Control[] | undefined;\n\t} else {\n\t\treturn jsxXml(ControlType, mSettings, key, xmlNamespaceMap);\n\t}\n};\n\n/**\n * Indicates that the next JSX call is rendered using the provided RenderManager.\n * @param renderManager The UI5 RenderManager to use for rendering\n * @param control The control to render\n * @param renderMethod The method to be rendered\n */\njsx.renderUsingRenderManager = function (renderManager: RenderManager, control: Control, renderMethod: Function): void {\n\trenderNextUsingRenderManager = renderManager;\n\tconst returnValue = renderMethod(control);\n\trenderNextUsingRenderManager = undefined;\n\treturnValue();\n};\njsx.defineXMLNamespaceMap = async function (namespaceMap: Record<string, string>, renderMethod: Function): Promise<unknown> {\n\txmlNamespaceMap = namespaceMap;\n\tconst returnValue = await renderMethod();\n\txmlNamespaceMap = {};\n\treturn returnValue;\n};\n/**\n * Indicates that the next JSX call should be rendered as XML.\n * @param renderMethod The method that needs to be rendered as XML\n * @returns The XML representation of the control\n */\njsx.renderAsXML = function <T>(renderMethod: () => T): T {\n\trenderNextAsXML = true;\n\tconst returnValue = renderMethod();\n\trenderNextAsXML = false;\n\treturn returnValue;\n};\n\nexport type Ref<T extends Element> = {\n\tcurrent?: T;\n\tsetCurrent(oControlInstance: T): void;\n};\n\nexport type JSXContext = {\n\townerControl?: Control & {\n\t\tcontrolReferences?: Record<string, Element>;\n\t\tcontrolReferencesId?: number;\n\t};\n\tview?: View;\n\tappComponent?: AppComponent;\n};\nlet jsxContext: JSXContext = {};\njsx.getContext = function (): JSXContext {\n\treturn jsxContext;\n};\n\nlet jsxFormatterContext: object = {};\njsx.setFormatterContext = function (context: object): void {\n\tjsxFormatterContext = context;\n};\n\njsx.getFormatterContext = function (): unknown {\n\treturn jsxFormatterContext;\n};\n\njsx.withContext = function <T>(context: JSXContext, functionToExecute: () => T): T {\n\tjsxContext = context;\n\tconst callBackReturn = functionToExecute();\n\tjsxContext = {};\n\treturn callBackReturn;\n};\n\n/**\n * JSX support for UI5 controls.\n * @returns The control or controls created\n */\nexport default jsx;\n"],"mappings":";;;;;;;EAmBA,IAAIA,eAAe,GAAG,KAAK;EAC3B,IAAIC,4BAAuD;EAC3D,IAAIC,eAAuC,GAAG,CAAC,CAAC;EAChD,MAAMC,GAAG,GAAG,SAAAA,CACXC,WAA2B,EAC3BC,SAA+F,EAC/FC,GAAW,EACgC;IAC3C,IAAI,CAACN,eAAe,IAAI,CAACC,4BAA4B,EAAE;MACtD,OAAOM,UAAU,CAACH,WAAW,EAAEC,SAAS,EAAEC,GAAG,EAAEE,UAAU,EAAEC,mBAAmB,CAAC;IAChF,CAAC,MAAM,IAAIR,4BAA4B,KAAKS,SAAS,EAAE;MACtD,OAAOC,gBAAgB,CACtBP,WAAW,EACXC,SAAS,EACTC,GAAG,EACHL,4BACD,CAAC;IACF,CAAC,MAAM;MACN,OAAOW,MAAM,CAACR,WAAW,EAAEC,SAAS,EAAEC,GAAG,EAAEJ,eAAe,CAAC;IAC5D;EACD,CAAC;;EAED;AACA;AACA;AACA;AACA;AACA;EACAC,GAAG,CAACU,wBAAwB,GAAG,UAAUC,aAA4B,EAAEC,OAAgB,EAAEC,YAAsB,EAAQ;IACtHf,4BAA4B,GAAGa,aAAa;IAC5C,MAAMG,WAAW,GAAGD,YAAY,CAACD,OAAO,CAAC;IACzCd,4BAA4B,GAAGS,SAAS;IACxCO,WAAW,CAAC,CAAC;EACd,CAAC;EACDd,GAAG,CAACe,qBAAqB,GAAG,gBAAgBC,YAAoC,EAAEH,YAAsB,EAAoB;IAC3Hd,eAAe,GAAGiB,YAAY;IAC9B,MAAMF,WAAW,GAAG,MAAMD,YAAY,CAAC,CAAC;IACxCd,eAAe,GAAG,CAAC,CAAC;IACpB,OAAOe,WAAW;EACnB,CAAC;EACD;AACA;AACA;AACA;AACA;EACAd,GAAG,CAACiB,WAAW,GAAG,UAAaJ,YAAqB,EAAK;IACxDhB,eAAe,GAAG,IAAI;IACtB,MAAMiB,WAAW,GAAGD,YAAY,CAAC,CAAC;IAClChB,eAAe,GAAG,KAAK;IACvB,OAAOiB,WAAW;EACnB,CAAC;EAeD,IAAIT,UAAsB,GAAG,CAAC,CAAC;EAC/BL,GAAG,CAACkB,UAAU,GAAG,YAAwB;IACxC,OAAOb,UAAU;EAClB,CAAC;EAED,IAAIC,mBAA2B,GAAG,CAAC,CAAC;EACpCN,GAAG,CAACmB,mBAAmB,GAAG,UAAUC,OAAe,EAAQ;IAC1Dd,mBAAmB,GAAGc,OAAO;EAC9B,CAAC;EAEDpB,GAAG,CAACqB,mBAAmB,GAAG,YAAqB;IAC9C,OAAOf,mBAAmB;EAC3B,CAAC;EAEDN,GAAG,CAACsB,WAAW,GAAG,UAAaF,OAAmB,EAAEG,iBAA0B,EAAK;IAClFlB,UAAU,GAAGe,OAAO;IACpB,MAAMI,cAAc,GAAGD,iBAAiB,CAAC,CAAC;IAC1ClB,UAAU,GAAG,CAAC,CAAC;IACf,OAAOmB,cAAc;EACtB,CAAC;;EAED;AACA;AACA;AACA;EAHA,OAIexB,GAAG;AAAA","ignoreList":[]}

package/src/sap/fe/base/jsx-runtime/jsx.ts

@@ -38,6 +38,13 @@ const jsx = function <T>(
 		return jsxXml(ControlType, mSettings, key, xmlNamespaceMap);
 	}
 };
+
+/**
+ * Indicates that the next JSX call is rendered using the provided RenderManager.
+ * @param renderManager The UI5 RenderManager to use for rendering
+ * @param control The control to render
+ * @param renderMethod The method to be rendered
+ */
 jsx.renderUsingRenderManager = function (renderManager: RenderManager, control: Control, renderMethod: Function): void {
 	renderNextUsingRenderManager = renderManager;
 	const returnValue = renderMethod(control);
@@ -96,4 +103,8 @@ jsx.withContext = function <T>(context: JSXContext, functionToExecute: () => T):
 	return callBackReturn;
 };
 
+/**
+ * JSX support for UI5 controls.
+ * @returns The control or controls created
+ */
 export default jsx;

package/src/sap/fe/base/library.js

@@ -22,7 +22,7 @@ sap.ui.define(["sap/ui/core/Lib"], function (Library) {
     controls: [],
     elements: [],
     // eslint-disable-next-line no-template-curly-in-string
-    version: "1.143.0",
+    version: "1.145.0",
     noLibraryCSS: true
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   });

package/src/sap/fe/base/types/sap.fe.base-auto-ext.d.js

@@ -0,0 +1,10 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2025 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  // This is autogenerated, do not edit
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":[],"sourceRoot":".","sources":["sap.fe.base-auto-ext.d.ts"],"sourcesContent":["// This is autogenerated, do not edit\n\ndeclare module \"sap/fe/base/library\" {\n\t// Public Exports\n\t/**\n\t * Library providing the base functionality of the runtime for SAP Fiori elements for OData V4.\n\t * @namespace\n\t * @public\n\t */\n\texport const feBaseNamespace = \"sap.fe.base\";\n}\n\ndeclare module \"sap/fe/base/ClassSupport\" {\n\timport type { $ControlSettings } from \"sap/ui/core/Control\";\n\timport type ControllerExtension from \"sap/ui/core/mvc/ControllerExtension\";\n\timport type OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\n\n\ttype OverrideDefinition = Record<string, Function>;\n\ttype UI5ControllerMethodDefinition = {\n\t\toverrideExecution?: OverrideExecution;\n\t\tpublic?: boolean;\n\t\tfinal?: boolean;\n\t};\n\n\texport type UI5ControlMetadataDefinition = {\n\t\tdefaultAggregation?: string;\n\t\tcontrollerExtensions: Record<string, typeof ControllerExtension | Function>;\n\t\tproperties: Record<string, UI5PropertyMetadata>;\n\t\taggregations: Record<string, UI5AggregationMetadata>;\n\t\treferences: Record<string, boolean>;\n\t\tassociations: Record<string, UI5AssociationMetadata>;\n\t\tmethods: Record<string, UI5ControllerMethodDefinition>;\n\t\tevents: Record<string, {}>;\n\t\tinterfaces: string[];\n\t\tlibrary?: string;\n\t\tdesigntime?: string;\n\t\tconfig?: {\n\t\t\tfullWidth?: boolean;\n\t\t};\n\t\tstateProperty?: string;\n\t\tstatePropertyDefaultValue?: unknown;\n\t\tmanifest?: string | unknown;\n\t\treturnTypes?: string[];\n\t\tbuildingBlockMetadata?: unknown;\n\t};\n\n\ttype ExtendWithObject<T, K> = T extends object ? K & { [TKey in keyof T]?: BindingInfoHolder<T[TKey]> } : K;\n\n\texport type BindingInfoHolder<T> = T & {\n\t\t__bindingInfo: {\n\t\t\tpath: string;\n\t\t\tmodel: string;\n\t\t\ttype: T;\n\t\t};\n\t};\n\n\texport type ControlPropertyNames<T> = {\n\t\t// needed because of the TS compiler\n\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t[K in keyof T]: T[K] extends Function ? never : K;\n\t}[keyof T];\n\t// Public Type Definitions\n\t/**\n\t * Definition of a UI5 property metadata.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport type UI5PropertyMetadata = {\n\t\ttype: string;\n\t\tbindable?: boolean;\n\t\trequired?: boolean;\n\t\tgroup?: string;\n\t\tdefaultValue?: unknown;\n\t\tbyValue?: boolean;\n\t\tisBindingInfo?: boolean;\n\t\tbindToState?: boolean;\n\t\texpectedAnnotations?: string[];\n\t\texpectedTypes?: string[];\n\t\tallowedValues?: string[];\n\t\tvisibility?: string;\n\t};\n\t/**\n\t * Definition of a UI5 aggregation metadata.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport type UI5AggregationMetadata = {\n\t\ttype: string;\n\t\taltTypes?: string[];\n\t\tmultiple?: boolean;\n\t\tisDefault?: boolean;\n\t\tdefaultValue?: unknown;\n\t\tdefaultClass?: unknown;\n\t\tsingularName?: string;\n\t\tvisibility?: string;\n\t\tforwarding?: object;\n\t};\n\t/**\n\t * Definition of a UI5 association metadata.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport type UI5AssociationMetadata = {\n\t\ttype: string;\n\t\tmultiple?: boolean;\n\t\tsingularName?: string;\n\t};\n\t/**\n\t * Returns the properties of a control.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport type PropertiesOf<T, K extends keyof T | undefined = undefined> = Partial<Pick<T, ControlPropertyNames<T>>> &\n\t\t(K extends keyof T ? Partial<Pick<T, K>> : {}) &\n\t\t$ControlSettings;\n\t/**\n\t * Represents the state object of a building block.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport type StateOf<T> = {\n\t\t[K in keyof T]: T[K] extends Array<infer U> | ReadonlyArray<infer U> ? ExtendWithObject<U, ReadonlyArray<U>> : T[K];\n\t};\n\n\t// Public Exports\n\t/**\n\t * Collection of decorators to support the creation of UI5 classes.\n\t * @namespace\n\t * @public\n\t */\n\texport const classSupportNamespace = \"sap.fe.base.ClassSupport\";\n\n\t/**\n\t * Allows to define a property that will hold the control state.\n\t *\n\t * Properties defined with this decorator will be automatically bound to the control state when used in JSX.\n\t * Arrays need to be bound using the `bindState` function.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t * @returns A property decorator\n\t */\n\texport function defineState(): PropertyDecorator;\n\n\t/* #endregion */\n\n\t/* #region CONTROL */\n\t/**\n\t * Indicates that the property shall be declared as an event on the control metadata.\n\t * @returns The decorated property\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport function event(): PropertyDecorator;\n\n\t/**\n\t * Defines the following property as a managed object in the control metadata.\n\t * @param attributeDefinition The property definition\n\t * @returns The decorated property.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport function property(attributeDefinition: UI5PropertyMetadata): PropertyDecorator;\n\n\t/**\n\t * Defines and configures the following aggregation in the control metadata.\n\t * @param aggregationDefinition The aggregation definition\n\t * @returns The decorated property.\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport function aggregation(aggregationDefinition: UI5AggregationMetadata): PropertyDecorator;\n\n\t/**\n\t * Defines and configures the following association in the control metadata.\n\t * @param ui5AssociationMetadata The definition of the association.\n\t * @returns The decorated property\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport function association(ui5AssociationMetadata: UI5AssociationMetadata): PropertyDecorator;\n\n\t/**\n\t * Defines in the metadata that this control implements a specific interface.\n\t * @param interfaceName The name of the implemented interface\n\t * @returns The decorated method\n\t * @public\n\t * @ui5-experimental-since 1.144.0\n\t */\n\texport function implementInterface(interfaceName: string): PropertyDecorator;\n\n\t/**\n\t * Indicates that the following class should define a UI5 control of the specified name.\n\t * @param target The fully qualified name of the UI5 class\n\t * @param metadataDefinition Additional inline metadata definition\n\t * @returns A class decorator that will create a ui5 class out of the TS class\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport function defineUI5Class(target: string, metadataDefinition?: Partial<UI5ControlMetadataDefinition>): ClassDecorator;\n}\n\ndeclare module \"sap/fe/base/BuildingBlockBase\" {\n\timport type { BindingToolkitExpression, PrimitiveType } from \"sap/fe/base/BindingToolkit\";\n\timport type { StateOf } from \"sap/fe/base/ClassSupport\";\n\timport type { PropertyBindingInfo } from \"sap/ui/base/ManagedObject\";\n\timport type Control from \"sap/ui/core/Control\";\n\timport { $ControlSettings } from \"sap/ui/core/Control\";\n\timport type UI5Element from \"sap/ui/core/Element\";\n\timport type { AccessibilityInfo } from \"sap/ui/core/library\";\n\timport type RenderManager from \"sap/ui/core/RenderManager\";\n\timport type Context from \"sap/ui/model/Context\";\n\n\t/**\n\t * Describes the settings that can be provided to the BuildingBlockBase constructor.\n\t */\n\texport interface $BuildingBlockBaseSettings<K = {}> extends $ControlSettings {\n\t\t/**\n\t\t * The current state value of the component.\n\t\t * This property holds the state data managed by the component, with the type\n\t\t * determined by the generic parameter K.\n\t\t */\n\t\tstate?: StateOf<K> | PropertyBindingInfo | `{${string}}`;\n\n\t\t/**\n\t\t * Optional content of generic type T.\n\t\t * This property holds the main data or payload for the containing object.\n\t\t * When undefined, it indicates that no content has been set or is available.\n\t\t * The specific type and structure of the content depends on the generic type parameter T.\n\t\t */\n\t\tcontent?: UI5Element;\n\n\t\t/**\n\t\t * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).\n\t\t */\n\t\tariaLabelledBy?: Control | string;\n\t}\n\n\t// Public Classes\n\t/**\n\t * Base class for building blocks.\n\t * This contains the low-level functionality of having a content aggregation and handling the rendering of the content without an actual DOM element.<br/>\n\t * The building block also defines a state object that can be used to store the state of the building block.<br/>\n\t * Accessibility and classes information are forwarded to the content control.<br/>\n\t * This class is not meant to be used directly, it's there for internal use only (and documentation)\n\t * @public\n\t */\n\tclass BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> extends Control {\n\t\t/**\n\t\t * Optional content of generic type T.\n\t\t *\n\t\t * This property holds the main data or payload for the containing object.\n\t\t * When undefined, it indicates that no content has been set or is available.\n\t\t * The specific type and structure of the content depends on the generic type parameter T.\n\t\t * @public\n\t\t */\n\t\tcontent?: T;\n\n\t\tgetContent(): T;\n\n\t\tsetContent(content: T): this;\n\n\t\tdestroyContent(): this;\n\n\t\t/**\n\t\t * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).\n\t\t * @public\n\t\t */\n\t\tariaLabelledBy: string[];\n\n\t\tgetAriaLabelledBy(): string[];\n\n\t\tsetAriaLabelledBy(ariaLabelledBy: string[]): this;\n\n\t\t/**\n\t\t * The current state value of the component.\n\t\t *\n\t\t * This property holds the state data managed by the component, with the type\n\t\t * determined by the generic parameter K.\n\t\t * @public\n\t\t */\n\t\tstate: StateOf<K>;\n\n\t\t/**\n\t\t * Shorthand for the BindingToolkit.bindState function with the current state object.\n\t\t * @param path A property in the state object\n\t\t * @returns The binding toolkit expression for the state\n\t\t * @public\n\t\t * @ui5-experimental-since 1.145.0\n\t\t */\n\t\tpublic bindState<ST extends PrimitiveType>(path: keyof K): BindingToolkitExpression<ST>;\n\n\t\t/**\n\t\t * Synchronizes a state property with another building block's state property.\n\t\t * @param propName Name of the property in the current state object\n\t\t * @param source The source building block\n\t\t * @param property The property in the source building block's state object\n\t\t */\n\t\tpublic syncStateProperty(propName: string, source: BuildingBlockBase, property: string): void;\n\n\t\tonStateChange(_changedProps: string[]): void;\n\t}\n\n\texport default BuildingBlockBase;\n}\n\ndeclare module \"sap/fe/base/BindingToolkit\" {\n\t// Public Exports\n\t/**\n\t * Collection of functions to support the manipulation of ui5 bindings\n\t * @public\n\t * @namespace\n\t * @ui5-experimental-since 1.145.0\n\t */\n\texport const bindingToolkitNamespace = \"sap.fe.base.BindingToolkit\";\n}\n"],"mappings":";;;;;;;EAAA;AAAA","ignoreList":[]}

package/src/sap/fe/base/types/sap.fe.base-auto-ext.d.ts

@@ -0,0 +1,315 @@
+// This is autogenerated, do not edit
+
+declare module "sap/fe/base/library" {
+	// Public Exports
+	/**
+	 * Library providing the base functionality of the runtime for SAP Fiori elements for OData V4.
+	 * @namespace
+	 * @public
+	 */
+	export const feBaseNamespace = "sap.fe.base";
+}
+
+declare module "sap/fe/base/ClassSupport" {
+	import type { $ControlSettings } from "sap/ui/core/Control";
+	import type ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+	import type OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+
+	type OverrideDefinition = Record<string, Function>;
+	type UI5ControllerMethodDefinition = {
+		overrideExecution?: OverrideExecution;
+		public?: boolean;
+		final?: boolean;
+	};
+
+	export type UI5ControlMetadataDefinition = {
+		defaultAggregation?: string;
+		controllerExtensions: Record<string, typeof ControllerExtension | Function>;
+		properties: Record<string, UI5PropertyMetadata>;
+		aggregations: Record<string, UI5AggregationMetadata>;
+		references: Record<string, boolean>;
+		associations: Record<string, UI5AssociationMetadata>;
+		methods: Record<string, UI5ControllerMethodDefinition>;
+		events: Record<string, {}>;
+		interfaces: string[];
+		library?: string;
+		designtime?: string;
+		config?: {
+			fullWidth?: boolean;
+		};
+		stateProperty?: string;
+		statePropertyDefaultValue?: unknown;
+		manifest?: string | unknown;
+		returnTypes?: string[];
+		buildingBlockMetadata?: unknown;
+	};
+
+	type ExtendWithObject<T, K> = T extends object ? K & { [TKey in keyof T]?: BindingInfoHolder<T[TKey]> } : K;
+
+	export type BindingInfoHolder<T> = T & {
+		__bindingInfo: {
+			path: string;
+			model: string;
+			type: T;
+		};
+	};
+
+	export type ControlPropertyNames<T> = {
+		// needed because of the TS compiler
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		[K in keyof T]: T[K] extends Function ? never : K;
+	}[keyof T];
+	// Public Type Definitions
+	/**
+	 * Definition of a UI5 property metadata.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export type UI5PropertyMetadata = {
+		type: string;
+		bindable?: boolean;
+		required?: boolean;
+		group?: string;
+		defaultValue?: unknown;
+		byValue?: boolean;
+		isBindingInfo?: boolean;
+		bindToState?: boolean;
+		expectedAnnotations?: string[];
+		expectedTypes?: string[];
+		allowedValues?: string[];
+		visibility?: string;
+	};
+	/**
+	 * Definition of a UI5 aggregation metadata.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export type UI5AggregationMetadata = {
+		type: string;
+		altTypes?: string[];
+		multiple?: boolean;
+		isDefault?: boolean;
+		defaultValue?: unknown;
+		defaultClass?: unknown;
+		singularName?: string;
+		visibility?: string;
+		forwarding?: object;
+	};
+	/**
+	 * Definition of a UI5 association metadata.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export type UI5AssociationMetadata = {
+		type: string;
+		multiple?: boolean;
+		singularName?: string;
+	};
+	/**
+	 * Returns the properties of a control.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export type PropertiesOf<T, K extends keyof T | undefined = undefined> = Partial<Pick<T, ControlPropertyNames<T>>> &
+		(K extends keyof T ? Partial<Pick<T, K>> : {}) &
+		$ControlSettings;
+	/**
+	 * Represents the state object of a building block.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export type StateOf<T> = {
+		[K in keyof T]: T[K] extends Array<infer U> | ReadonlyArray<infer U> ? ExtendWithObject<U, ReadonlyArray<U>> : T[K];
+	};
+
+	// Public Exports
+	/**
+	 * Collection of decorators to support the creation of UI5 classes.
+	 * @namespace
+	 * @public
+	 */
+	export const classSupportNamespace = "sap.fe.base.ClassSupport";
+
+	/**
+	 * Allows to define a property that will hold the control state.
+	 *
+	 * Properties defined with this decorator will be automatically bound to the control state when used in JSX.
+	 * Arrays need to be bound using the `bindState` function.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 * @returns A property decorator
+	 */
+	export function defineState(): PropertyDecorator;
+
+	/* #endregion */
+
+	/* #region CONTROL */
+	/**
+	 * Indicates that the property shall be declared as an event on the control metadata.
+	 * @returns The decorated property
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export function event(): PropertyDecorator;
+
+	/**
+	 * Defines the following property as a managed object in the control metadata.
+	 * @param attributeDefinition The property definition
+	 * @returns The decorated property.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export function property(attributeDefinition: UI5PropertyMetadata): PropertyDecorator;
+
+	/**
+	 * Defines and configures the following aggregation in the control metadata.
+	 * @param aggregationDefinition The aggregation definition
+	 * @returns The decorated property.
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export function aggregation(aggregationDefinition: UI5AggregationMetadata): PropertyDecorator;
+
+	/**
+	 * Defines and configures the following association in the control metadata.
+	 * @param ui5AssociationMetadata The definition of the association.
+	 * @returns The decorated property
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export function association(ui5AssociationMetadata: UI5AssociationMetadata): PropertyDecorator;
+
+	/**
+	 * Defines in the metadata that this control implements a specific interface.
+	 * @param interfaceName The name of the implemented interface
+	 * @returns The decorated method
+	 * @public
+	 * @ui5-experimental-since 1.144.0
+	 */
+	export function implementInterface(interfaceName: string): PropertyDecorator;
+
+	/**
+	 * Indicates that the following class should define a UI5 control of the specified name.
+	 * @param target The fully qualified name of the UI5 class
+	 * @param metadataDefinition Additional inline metadata definition
+	 * @returns A class decorator that will create a ui5 class out of the TS class
+	 * @public
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export function defineUI5Class(target: string, metadataDefinition?: Partial<UI5ControlMetadataDefinition>): ClassDecorator;
+}
+
+declare module "sap/fe/base/BuildingBlockBase" {
+	import type { BindingToolkitExpression, PrimitiveType } from "sap/fe/base/BindingToolkit";
+	import type { StateOf } from "sap/fe/base/ClassSupport";
+	import type { PropertyBindingInfo } from "sap/ui/base/ManagedObject";
+	import type Control from "sap/ui/core/Control";
+	import { $ControlSettings } from "sap/ui/core/Control";
+	import type UI5Element from "sap/ui/core/Element";
+	import type { AccessibilityInfo } from "sap/ui/core/library";
+	import type RenderManager from "sap/ui/core/RenderManager";
+	import type Context from "sap/ui/model/Context";
+
+	/**
+	 * Describes the settings that can be provided to the BuildingBlockBase constructor.
+	 */
+	export interface $BuildingBlockBaseSettings<K = {}> extends $ControlSettings {
+		/**
+		 * The current state value of the component.
+		 * This property holds the state data managed by the component, with the type
+		 * determined by the generic parameter K.
+		 */
+		state?: StateOf<K> | PropertyBindingInfo | `{${string}}`;
+
+		/**
+		 * Optional content of generic type T.
+		 * This property holds the main data or payload for the containing object.
+		 * When undefined, it indicates that no content has been set or is available.
+		 * The specific type and structure of the content depends on the generic type parameter T.
+		 */
+		content?: UI5Element;
+
+		/**
+		 * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).
+		 */
+		ariaLabelledBy?: Control | string;
+	}
+
+	// Public Classes
+	/**
+	 * Base class for building blocks.
+	 * This contains the low-level functionality of having a content aggregation and handling the rendering of the content without an actual DOM element.<br/>
+	 * The building block also defines a state object that can be used to store the state of the building block.<br/>
+	 * Accessibility and classes information are forwarded to the content control.<br/>
+	 * This class is not meant to be used directly, it's there for internal use only (and documentation)
+	 * @public
+	 */
+	class BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> extends Control {
+		/**
+		 * Optional content of generic type T.
+		 *
+		 * This property holds the main data or payload for the containing object.
+		 * When undefined, it indicates that no content has been set or is available.
+		 * The specific type and structure of the content depends on the generic type parameter T.
+		 * @public
+		 */
+		content?: T;
+
+		getContent(): T;
+
+		setContent(content: T): this;
+
+		destroyContent(): this;
+
+		/**
+		 * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).
+		 * @public
+		 */
+		ariaLabelledBy: string[];
+
+		getAriaLabelledBy(): string[];
+
+		setAriaLabelledBy(ariaLabelledBy: string[]): this;
+
+		/**
+		 * The current state value of the component.
+		 *
+		 * This property holds the state data managed by the component, with the type
+		 * determined by the generic parameter K.
+		 * @public
+		 */
+		state: StateOf<K>;
+
+		/**
+		 * Shorthand for the BindingToolkit.bindState function with the current state object.
+		 * @param path A property in the state object
+		 * @returns The binding toolkit expression for the state
+		 * @public
+		 * @ui5-experimental-since 1.145.0
+		 */
+		public bindState<ST extends PrimitiveType>(path: keyof K): BindingToolkitExpression<ST>;
+
+		/**
+		 * Synchronizes a state property with another building block's state property.
+		 * @param propName Name of the property in the current state object
+		 * @param source The source building block
+		 * @param property The property in the source building block's state object
+		 */
+		public syncStateProperty(propName: string, source: BuildingBlockBase, property: string): void;
+
+		onStateChange(_changedProps: string[]): void;
+	}
+
+	export default BuildingBlockBase;
+}
+
+declare module "sap/fe/base/BindingToolkit" {
+	// Public Exports
+	/**
+	 * Collection of functions to support the manipulation of ui5 bindings
+	 * @public
+	 * @namespace
+	 * @ui5-experimental-since 1.145.0
+	 */
+	export const bindingToolkitNamespace = "sap.fe.base.BindingToolkit";
+}

package/src/sap/fe/base/types/sap.fe.base-manual-ext.d.js

@@ -0,0 +1,9 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2025 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuIiwic291cmNlcyI6WyJzYXAuZmUuYmFzZS1tYW51YWwtZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZGVjbGFyZSBuYW1lc3BhY2UgSlNYIHtcblx0ZXhwb3J0IHR5cGUgQ29tbWFuZFByb3BlcnRpZXMgPSBgY21kOiR7c3RyaW5nfXwke3N0cmluZ31gO1xuXHRleHBvcnQgdHlwZSBSZWY8VD4gPSB7XG5cdFx0Y3VycmVudD86IFQ7XG5cdFx0c2V0Q3VycmVudChvQ29udHJvbEluc3RhbmNlOiBUKTogdm9pZDtcblx0fTtcblx0aW50ZXJmYWNlIEludHJpbnNpY0VsZW1lbnRzIHtcblx0XHRkaXY6IHsgaWQ/OiBzdHJpbmc7IGNsYXNzPzogc3RyaW5nOyByZWY/OiBSZWY8bmV2ZXI+OyB0YWJpbmRleD86IG51bWJlcjsgcm9sZT86IHN0cmluZyB9O1xuXHRcdHNwYW46IHsgaWQ/OiBzdHJpbmc7IGNsYXNzPzogc3RyaW5nOyByZWY/OiBSZWY8bmV2ZXI+OyByb2xlPzogc3RyaW5nIH07XG5cdFx0c2xvdDogeyBuYW1lOiBzdHJpbmcgfTtcblx0fVxuXHRpbnRlcmZhY2UgSW50cmluc2ljQ2xhc3NBdHRyaWJ1dGVzPFQ+IHtcblx0XHRpZD86IHN0cmluZztcblx0XHRjbGFzcz86IHN0cmluZztcblx0XHRiaW5kaW5nPzogc3RyaW5nIHwgUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblx0XHRbXCJ4bWxuczpmbFwiXT86IHN0cmluZztcblx0XHRbXCJjb3JlOnJlcXVpcmVcIl0/OiBzdHJpbmc7XG5cdFx0W1wibG9nOnNvdXJjZVBhdGhcIl0/OiBzdHJpbmc7XG5cdFx0W1wiY3VzdG9tRGF0YTplbnRpdHlUeXBlXCJdPzogc3RyaW5nO1xuXHRcdFtcImZsOmRlbGVnYXRlXCJdPzogc3RyaW5nIHwgeyBuYW1lOiBzdHJpbmc7IGRlbGVnYXRlVHlwZTogc3RyaW5nIH07XG5cdFx0W1wiZHQ6ZGVzaWdudGltZVwiXT86IHN0cmluZyB8IHsgbmFtZTogc3RyaW5nOyBkZWxlZ2F0ZVR5cGU6IHN0cmluZyB9O1xuXHRcdFtcImZsOmZsZXhpYmlsaXR5XCJdPzogc3RyaW5nO1xuXHRcdHJlZj86IFJlZjxUPjtcblx0XHRbXCJqc3g6Y29tbWFuZFwiXT86IENvbW1hbmRQcm9wZXJ0aWVzO1xuXHR9XG59XG5cbmRlY2xhcmUgbW9kdWxlIFwic2FwL2ZlL2Jhc2UvQmluZGluZ1Rvb2xraXRcIiB7XG5cdGV4cG9ydCB0eXBlIFBhdGhJbk1vZGVsRXhwcmVzc2lvbjxLPiA9IG5ldmVyO1xuXHRleHBvcnQgdHlwZSBDb25zdGFudEV4cHJlc3Npb248Sz4gPSBuZXZlcjtcblx0ZXhwb3J0IHR5cGUgQmluZGluZ1Rvb2xraXRFeHByZXNzaW9uPEs+ID0gbmV2ZXI7XG5cdGV4cG9ydCB0eXBlIFByaW1pdGl2ZVR5cGUgPSBzdHJpbmcgfCBudW1iZXIgfCBiaWdpbnQgfCBib29sZWFuIHwgb2JqZWN0IHwgbnVsbCB8IHVuZGVmaW5lZDtcbn1cbiJdLCJtYXBwaW5ncyI6IiIsImlnbm9yZUxpc3QiOltdfQ==

package/src/sap/fe/base/types/sap.fe.base-manual-ext.d.ts

@@ -0,0 +1,33 @@
+declare namespace JSX {
+	export type CommandProperties = `cmd:${string}|${string}`;
+	export type Ref<T> = {
+		current?: T;
+		setCurrent(oControlInstance: T): void;
+	};
+	interface IntrinsicElements {
+		div: { id?: string; class?: string; ref?: Ref<never>; tabindex?: number; role?: string };
+		span: { id?: string; class?: string; ref?: Ref<never>; role?: string };
+		slot: { name: string };
+	}
+	interface IntrinsicClassAttributes<T> {
+		id?: string;
+		class?: string;
+		binding?: string | Record<string, string>;
+		["xmlns:fl"]?: string;
+		["core:require"]?: string;
+		["log:sourcePath"]?: string;
+		["customData:entityType"]?: string;
+		["fl:delegate"]?: string | { name: string; delegateType: string };
+		["dt:designtime"]?: string | { name: string; delegateType: string };
+		["fl:flexibility"]?: string;
+		ref?: Ref<T>;
+		["jsx:command"]?: CommandProperties;
+	}
+}
+
+declare module "sap/fe/base/BindingToolkit" {
+	export type PathInModelExpression<K> = never;
+	export type ConstantExpression<K> = never;
+	export type BindingToolkitExpression<K> = never;
+	export type PrimitiveType = string | number | bigint | boolean | object | null | undefined;
+}