From e63ed4144a659519d36e73576ebc440348e54b55 Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Fri, 3 Jul 2026 14:49:54 +0200
Subject: [PATCH 1/6] Use a template for generating interfaces

---
 .../typings-generator/generateClientTypes.ts  | 68 +++++++++----------
 .../typings-generator/generatePreviewTypes.ts | 49 ++++++-------
 .../src/typings-generator/helpers.ts          |  9 +++
 3 files changed, 65 insertions(+), 61 deletions(-)

diff --git a/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts b/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
index be6883d5..8aa83a5b 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
@@ -1,5 +1,5 @@
 import { ActionVariableTypes, Property, ReturnType, SystemProperty } from "./WidgetXml";
-import { capitalizeFirstLetter, commasAnd, extractProperties } from "./helpers";
+import { capitalizeFirstLetter, commasAnd, extractProperties, templateInterface } from "./helpers";
 
 export function generateClientTypes(
     widgetName: string,
@@ -13,33 +13,31 @@ export function generateClientTypes(
 
     const isLabeled = systemProperties.some(p => p.$.key === "Label");
     const results = Array.of<string>();
+    const propertyTypes = generateClientTypeProperties(properties, isNative, results, resolveProp);
     results.push(
         isNative
-            ? `export interface ${widgetName}Props<Style> {
-    name: string;
-    style: Style[];
-${generateClientTypeBody(properties, true, results, resolveProp)}
-}`
-            : `export interface ${widgetName}ContainerProps {
-    name: string;${
-        !isLabeled
-            ? `
-    class: string;
-    style?: CSSProperties;`
-            : ""
-    }
-    tabIndex?: number;${
-        isLabeled
-            ? `
-    id: string;`
-            : ""
-    }
-${generateClientTypeBody(properties, false, results, resolveProp)}
-}`
+            ? generateNativeProps(widgetName, propertyTypes)
+            : generateWebProps(widgetName, isLabeled, propertyTypes)
     );
     return results;
 }
 
+function generateWebProps(widgetName: string, isLabeled: boolean, propertyTypes: string[]) {
+    return templateInterface(
+        `${widgetName}ContainerProps`,
+        "name: string;",
+        !isLabeled ? `class: string;` : "",
+        !isLabeled ? `style?: CSSProperties;` : "",
+        `tabIndex?: number;`,
+        isLabeled ? `id: string;` : "",
+        ...propertyTypes
+    );
+}
+
+function generateNativeProps(widgetName: string, propertyTypes: string[]) {
+    return templateInterface(`${widgetName}Props<Style>`, "name: string;", "style: Style[];", ...propertyTypes);
+}
+
 function isEmbeddedOnChangeAction(propertyPath: string, properties: Property[]): boolean {
     return properties.some(prop => {
         if (prop.$.onChange === propertyPath) {
@@ -54,12 +52,12 @@ function isEmbeddedOnChangeAction(propertyPath: string, properties: Property[]):
     });
 }
 
-function generateClientTypeBody(
+function generateClientTypeProperties(
     properties: Property[],
     isNative: boolean,
     generatedTypes: string[],
     resolveProp: (key: string) => Property | undefined
-) {
+): string[] {
     return properties
         .filter(prop => {
             if (prop.$.type === "action" && isEmbeddedOnChangeAction(prop.$.key, properties)) {
@@ -70,16 +68,11 @@ function generateClientTypeBody(
             }
             return true;
         })
-        .map(
-            prop =>
-                `    ${prop.$.key}${isOptionalProp(prop, resolveProp) ? "?" : ""}: ${toClientPropType(
-                    prop,
-                    isNative,
-                    generatedTypes,
-                    resolveProp
-                )};`
-        )
-        .join("\n");
+        .map(prop => {
+            const optional = isOptionalProp(prop, resolveProp) ? "?" : "";
+            const type = toClientPropType(prop, isNative, generatedTypes, resolveProp);
+            return `${prop.$.key}${optional}: ${type};`;
+        });
 }
 
 function isOptionalProp(prop: Property, resolveProp: (key: string) => Property | undefined) {
@@ -216,9 +209,10 @@ function toClientPropType(
                 key.startsWith("../") ? resolveProp(key.substring(3)) : childProperties.find(p => p.$.key === key);
 
             generatedTypes.push(
-                `export interface ${childType} {
-${generateClientTypeBody(childProperties, isNative, generatedTypes, resolveChildProp)}
-}`
+                templateInterface(
+                    childType,
+                    ...generateClientTypeProperties(childProperties, isNative, generatedTypes, resolveChildProp)
+                )
             );
             return prop.$.isList === "true" ? `${childType}[]` : childType;
         case "widgets":
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/generatePreviewTypes.ts b/packages/pluggable-widgets-tools/src/typings-generator/generatePreviewTypes.ts
index ad13ee39..25391922 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/generatePreviewTypes.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/generatePreviewTypes.ts
@@ -1,5 +1,5 @@
 import { Property, SystemProperty } from "./WidgetXml";
-import { capitalizeFirstLetter, extractProperties } from "./helpers";
+import { capitalizeFirstLetter, extractProperties, templateInterface } from "./helpers";
 import { hasOptionalDataSource, toUniqueUnionType } from "./generateClientTypes";
 
 export function generatePreviewTypes(
@@ -14,38 +14,38 @@ export function generatePreviewTypes(
         return properties.find(p => p.$.key === key);
     }
 
-    results.push(`export interface ${widgetName}PreviewProps {${
-        !isLabeled
-            ? `
-    /**
-     * @deprecated Deprecated since version 9.18.0. Please use class property instead.
-     */
-    className: string;
-    class: string;
-    style: string;
-    styleObject?: CSSProperties;`
-            : ""
-    }
-    readOnly: boolean;
-    renderMode: "design" | "xray" | "structure";
-    translate: (text: string) => string;
-${generatePreviewTypeBody(properties, results, resolveProp)}
-}`);
+    results.push(
+        templateInterface(
+            `${widgetName}PreviewProps`,
+            isLabeled ? "" : containerStylingProps,
+            "readOnly: boolean;",
+            `renderMode: "design" | "xray" | "structure";`,
+            "translate: (text: string) => string;",
+            ...generatePreviewTypeBody(properties, results, resolveProp)
+        )
+    );
     return results;
 }
 
+const containerStylingProps = `/**
+ * @deprecated Deprecated since version 9.18.0. Please use class property instead.
+ */
+className: string;
+class: string;
+style: string;
+styleObject?: CSSProperties;`;
+
 function generatePreviewTypeBody(
     properties: Property[],
     generatedTypes: string[],
     resolveProp: (key: string) => Property | undefined
-) {
+): string[] {
     return properties
         .filter(prop => {
             if (prop.$.type === "datasource" && prop.$.isLinked) return false;
             return true;
         })
-        .map(prop => `    ${prop.$.key}: ${toPreviewPropType(prop, generatedTypes, resolveProp)};`)
-        .join("\n");
+        .map(prop => `${prop.$.key}: ${toPreviewPropType(prop, generatedTypes, resolveProp)};`);
 }
 
 function toPreviewPropType(
@@ -91,9 +91,10 @@ function toPreviewPropType(
                 key.startsWith("../") ? resolveProp(key.substring(3)) : childProperties.find(p => p.$.key === key);
 
             generatedTypes.push(
-                `export interface ${childType} {
-${generatePreviewTypeBody(childProperties, generatedTypes, resolveChildProp)}
-}`
+                templateInterface(
+                    childType,
+                    ...generatePreviewTypeBody(childProperties, generatedTypes, resolveChildProp)
+                )
             );
             return prop.$.isList === "true" ? `${childType}[]` : childType;
         case "widgets":
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts b/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
index 40e60bed..901e0a3c 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
@@ -37,3 +37,12 @@ export function groupBy<T, Groups extends string>(groupSelector: (item: T) => Gr
         return { ...reduction, [group]: [...(reduction[group] ?? []), item] };
     };
 }
+
+export function templateInterface(name: string, ...properties: string[]): string {
+    return `export interface ${name} {
+    ${properties
+        .filter(x => x !== "")
+        .map(p => p.replace(/\n/g, "\n    "))
+        .join("\n    ")}
+}`;
+}

From 04c0e8a2ae77c0db85d3573396cb8b6c9e065ed9 Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Fri, 3 Jul 2026 15:38:50 +0200
Subject: [PATCH 2/6] Add type generator for SystemTexts

---
 .../src/typings-generator/WidgetXml.ts        | 50 ++++++++++++++
 .../src/typings-generator/generate.ts         |  5 +-
 .../typings-generator/generateClientTypes.ts  | 19 ++++--
 .../typings-generator/generateSystemTexts.ts  | 66 +++++++++++++++++++
 .../src/typings-generator/helpers.ts          |  4 ++
 5 files changed, 138 insertions(+), 6 deletions(-)
 create mode 100644 packages/pluggable-widgets-tools/src/typings-generator/generateSystemTexts.ts

diff --git a/packages/pluggable-widgets-tools/src/typings-generator/WidgetXml.ts b/packages/pluggable-widgets-tools/src/typings-generator/WidgetXml.ts
index f6220ef6..5b4ebb6b 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/WidgetXml.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/WidgetXml.ts
@@ -106,6 +106,56 @@ export interface SystemProperty {
     };
 }
 
+export interface TextSystemProperty {
+    $: {
+        key: "Text";
+    };
+    text: SystemText[];
+    externalTexts: ExternalSystemTextNamespace[];
+}
+
+export interface SystemText {
+    $: {
+        key: string;
+    };
+    caption: string;
+    translations: SystemTextTranslationCollection[];
+    parameters: SystemTextParameterCollection[];
+}
+
+export interface SystemTextParameterCollection {
+    parameter: SystemTextParameter[];
+}
+
+export interface SystemTextTranslationCollection {
+    translation: SystemTextTranslation[];
+}
+
+export interface SystemTextTranslation {
+    $: {
+        lang: string;
+    };
+}
+
+export interface SystemTextParameter {
+    $: {
+        caption: string;
+    };
+}
+
+export interface ExternalSystemTextNamespace {
+    $: {
+        widgetId: string;
+    };
+    text: ExternalSystemText[];
+}
+
+export interface ExternalSystemText {
+    $: {
+        key: string;
+    };
+}
+
 export interface Enumeration {
     enumerationValue: EnumerationValue[];
 }
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/generate.ts b/packages/pluggable-widgets-tools/src/typings-generator/generate.ts
index 400a03d4..a5672e12 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/generate.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/generate.ts
@@ -1,6 +1,7 @@
 import { generateClientTypes } from "./generateClientTypes";
 import { generateImports, ImportableModule } from "./generateImports";
 import { generatePreviewTypes } from "./generatePreviewTypes";
+import { generateTranslations } from "./generateSystemTexts";
 import { extractProperties, extractSystemProperties } from "./helpers";
 import { WidgetXml } from "./WidgetXml";
 
@@ -52,13 +53,15 @@ export function generateForWidget(widgetXml: WidgetXml, widgetName: string) {
     const properties = extractProperties(propElements).filter(prop => prop?.$?.key);
     const systemProperties = extractSystemProperties(propElements).filter(prop => prop?.$?.key);
 
+    const translations = generateTranslations(systemProperties);
     const clientTypes = generateClientTypes(widgetName, properties, systemProperties, isNative);
     const modelerTypes = generatePreviewTypes(widgetName, properties, systemProperties);
 
     const generatedTypesCode = clientTypes
         .slice(0, clientTypes.length - 1) // all client auxiliary types
         .concat(modelerTypes.slice(0, modelerTypes.length - 1)) // all preview auxiliary types
-        .concat([clientTypes[clientTypes.length - 1], modelerTypes[modelerTypes.length - 1]])
+        .concat([translations, clientTypes[clientTypes.length - 1], modelerTypes[modelerTypes.length - 1]])
+        .filter(t => t !== "")
         .join("\n\n");
 
     const imports = generateImports(importableModules, generatedTypesCode);
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts b/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
index 8aa83a5b..d761163f 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/generateClientTypes.ts
@@ -1,4 +1,5 @@
 import { ActionVariableTypes, Property, ReturnType, SystemProperty } from "./WidgetXml";
+import { systemTextsProperty } from "./generateSystemTexts";
 import { capitalizeFirstLetter, commasAnd, extractProperties, templateInterface } from "./helpers";
 
 export function generateClientTypes(
@@ -12,17 +13,18 @@ export function generateClientTypes(
     }
 
     const isLabeled = systemProperties.some(p => p.$.key === "Label");
+    const hasTranslations = systemProperties.some(p => p.$.key === "Text");
     const results = Array.of<string>();
     const propertyTypes = generateClientTypeProperties(properties, isNative, results, resolveProp);
     results.push(
         isNative
-            ? generateNativeProps(widgetName, propertyTypes)
-            : generateWebProps(widgetName, isLabeled, propertyTypes)
+            ? generateNativeProps(widgetName, hasTranslations, propertyTypes)
+            : generateWebProps(widgetName, isLabeled, hasTranslations, propertyTypes)
     );
     return results;
 }
 
-function generateWebProps(widgetName: string, isLabeled: boolean, propertyTypes: string[]) {
+function generateWebProps(widgetName: string, isLabeled: boolean, hasTranslations: boolean, propertyTypes: string[]) {
     return templateInterface(
         `${widgetName}ContainerProps`,
         "name: string;",
@@ -30,12 +32,19 @@ function generateWebProps(widgetName: string, isLabeled: boolean, propertyTypes:
         !isLabeled ? `style?: CSSProperties;` : "",
         `tabIndex?: number;`,
         isLabeled ? `id: string;` : "",
+        hasTranslations ? systemTextsProperty : "",
         ...propertyTypes
     );
 }
 
-function generateNativeProps(widgetName: string, propertyTypes: string[]) {
-    return templateInterface(`${widgetName}Props<Style>`, "name: string;", "style: Style[];", ...propertyTypes);
+function generateNativeProps(widgetName: string, hasTranslations: boolean, propertyTypes: string[]) {
+    return templateInterface(
+        `${widgetName}Props<Style>`,
+        "name: string;",
+        "style: Style[];",
+        hasTranslations ? systemTextsProperty : "",
+        ...propertyTypes
+    );
 }
 
 function isEmbeddedOnChangeAction(propertyPath: string, properties: Property[]): boolean {
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/generateSystemTexts.ts b/packages/pluggable-widgets-tools/src/typings-generator/generateSystemTexts.ts
new file mode 100644
index 00000000..c38041cc
--- /dev/null
+++ b/packages/pluggable-widgets-tools/src/typings-generator/generateSystemTexts.ts
@@ -0,0 +1,66 @@
+import { ensure } from "../common";
+import { capitalizeFirstLetter, lowercaseFirstLetter, templateInterface } from "./helpers";
+import { SystemProperty, TextSystemProperty } from "./WidgetXml";
+
+const STAR = "*" as const;
+type Star = typeof STAR;
+type Text = { key: string; parameters: string[] } | { widgetId: string; key: Star | string[] };
+
+function textsFromSystemProperty(node: SystemProperty): Text[] {
+    if (!isTextSystemProperty(node)) return [];
+
+    return [
+        ...(node.text ?? []).map(t => ({
+            key: t.$.key,
+            parameters: (t.parameters ?? []).flatMap(pp => (pp.parameter ?? []).map(p => p.$.caption))
+        })),
+        ...(node.externalTexts ?? []).map(e => {
+            return {
+                widgetId: e.$.widgetId,
+                key: e.text === undefined ? STAR : e.text.map(t => t.$.key)
+            };
+        })
+    ];
+}
+
+function isTextSystemProperty(node: SystemProperty): node is TextSystemProperty {
+    return node.$.key === "Text";
+}
+
+function generateTextType(t: Text): string {
+    if ("widgetId" in t) {
+        if (t.key === STAR) {
+            return `"${t.widgetId}": [key: string, params?: string[]]`;
+        }
+        return `"${t.widgetId}": [key: ${t.key.map(key => `"${key}"`).join(" | ")}, params?: string[]]`;
+    }
+
+    const parameterTypes = t.parameters.map(p => `${normalizeParameterName(p)}: string`);
+    const propertyType = parameterTypes.length > 0 ? `[params: [${parameterTypes.join(", ")}]]` : "[]";
+    return `"${t.key}": ${propertyType};`;
+}
+
+/***
+ * Normalize parameter captions to be legal Javascript function parameter names.
+ * @example
+ * // returns amountEUR
+ * normalizeParameterName("Amount (EUR)")
+ */
+function normalizeParameterName(name: string) {
+    const elements = ensure(name.match(/\w+/g));
+    return lowercaseFirstLetter(elements.map(el => capitalizeFirstLetter(el)).join(""));
+}
+
+export function generateTranslations(systemProperties: SystemProperty[]): string {
+    const texts = systemProperties.flatMap(textsFromSystemProperty);
+
+    if (texts.length === 0) {
+        return "";
+    }
+
+    return templateInterface("Translations", ...texts.map(generateTextType));
+}
+
+export const systemTextsProperty = `texts: {
+    translate: <K extends keyof Translations>(key: K, ...params: Translations[K]) => string
+}`;
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts b/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
index 901e0a3c..1ffc6c4a 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/helpers.ts
@@ -18,6 +18,10 @@ export function capitalizeFirstLetter(text: string): string {
     return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
+export function lowercaseFirstLetter(text: string): string {
+    return text.charAt(0).toLowerCase() + text.slice(1);
+}
+
 export function commasAnd(arr: string[]) {
     return arr.slice(0, -1).join(", ") + (arr.length > 1 ? " and " : "") + arr[arr.length - 1];
 }

From df47ed51be25d43e03cdec4a2f1aae16d20b0446 Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Tue, 30 Jun 2026 11:54:00 +0200
Subject: [PATCH 3/6] Change signature of ensure to fix type inference

---
 packages/pluggable-widgets-tools/src/common.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/pluggable-widgets-tools/src/common.ts b/packages/pluggable-widgets-tools/src/common.ts
index 83bae0ef..450fbc59 100644
--- a/packages/pluggable-widgets-tools/src/common.ts
+++ b/packages/pluggable-widgets-tools/src/common.ts
@@ -1,4 +1,4 @@
-export function ensure<T>(arg?: T, label: string = "argument"): T {
+export function ensure<T>(arg: T | undefined | null, label: string = "argument"): T {
     if (arg === null || arg === undefined) {
         throw new Error(`Did not expect ${label} to be ${arg}`);
     }

From 1a57d3692deeada4850462d4a7c9b8bc852a284f Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Fri, 3 Jul 2026 16:17:07 +0200
Subject: [PATCH 4/6] Add generation tests for systemtexts

---
 .../typings-generator/__tests__/index.spec.ts | 12 +++++
 .../__tests__/inputs/systemtexts.ts           | 46 +++++++++++++++++++
 .../__tests__/outputs/systemtexts.ts          | 45 ++++++++++++++++++
 3 files changed, 103 insertions(+)
 create mode 100644 packages/pluggable-widgets-tools/src/typings-generator/__tests__/inputs/systemtexts.ts
 create mode 100644 packages/pluggable-widgets-tools/src/typings-generator/__tests__/outputs/systemtexts.ts

diff --git a/packages/pluggable-widgets-tools/src/typings-generator/__tests__/index.spec.ts b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/index.spec.ts
index f624b586..ea7bdb1b 100644
--- a/packages/pluggable-widgets-tools/src/typings-generator/__tests__/index.spec.ts
+++ b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/index.spec.ts
@@ -55,6 +55,8 @@ import {
     singleObjectDatasourceNativeOutput,
     singleObjectDatasourceWebOutput
 } from "./outputs/single-object-datasource";
+import { systemTextsInput, systemTextsInputNative } from "./inputs/systemtexts";
+import { systemTextsNativeOutput, systemTextsOutput } from "./outputs/systemtexts";
 
 describe("Generating tests", () => {
     it("Generates a parsed typing from XML for native", () => {
@@ -266,6 +268,16 @@ describe("Generating tests", () => {
         const newContent = generateNativeTypesFor(singleObjectDatasourceInputNative);
         expect(newContent).toBe(singleObjectDatasourceNativeOutput);
     });
+
+    it("Generates a parsed typing from XML for web using system texts", () => {
+        const newContent = generateFullTypesFor(systemTextsInput);
+        expect(newContent).toBe(systemTextsOutput);
+    });
+
+    it("Generates a parsed typing from XML for native using system texts", () => {
+        const newContent = generateNativeTypesFor(systemTextsInputNative);
+        expect(newContent).toBe(systemTextsNativeOutput);
+    });
 });
 
 function generateFullTypesFor(xml: string) {
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/__tests__/inputs/systemtexts.ts b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/inputs/systemtexts.ts
new file mode 100644
index 00000000..42fb6b79
--- /dev/null
+++ b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/inputs/systemtexts.ts
@@ -0,0 +1,46 @@
+const systemProperty = `<systemProperty key="Text">
+    <text key="photo">
+        <caption>Photo</caption>
+        <translations>
+            <translation lang="en_US">Photo</translation>
+            <translation lang="nl_NL">Foto</translation>
+        </translations>
+    </text>
+    <text key="photo_count">
+        <caption>Photo Count</caption>
+        <translations>
+            <translation lang="en_US">{1} Photos</translation>
+            <translation lang="nl_NL">{1} Foto's</translation>
+        </translations>
+        <parameters>
+            <parameter caption="Count" />
+        </parameters>
+    </text>
+    <externalTexts widgetId="mendix.textbox.TextBox">
+        <text key="label" />
+        <text key="placeholder" />
+    </externalTexts>
+    <externalTexts widgetId="mendix.datagrid.DataGrid" />
+</systemProperty>`;
+
+export const systemTextsInput = `<?xml version="1.0" encoding="utf-8"?>
+<widget id="mendix.mywidget.MyWidget" needsEntityContext="true" offlineCapable="true" pluginWidget="true"
+        xmlns="http://www.mendix.com/widget/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.mendix.com/widget/1.0/ ../xsd/widget.xsd">
+    <properties>
+        <propertyGroup caption="General">
+            ${systemProperty}
+        </propertyGroup>
+    </properties>
+</widget>`;
+
+export const systemTextsInputNative = `<?xml version="1.0" encoding="utf-8"?>
+<widget id="mendix.mywidget.MyWidget" needsEntityContext="true" offlineCapable="true" pluginWidget="true" supportedPlatform="Native"
+        xmlns="http://www.mendix.com/widget/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.mendix.com/widget/1.0/ ../xsd/widget.xsd">
+    <properties>
+         <propertyGroup caption="General">
+            ${systemProperty}
+        </propertyGroup>
+    </properties>
+</widget>`;
diff --git a/packages/pluggable-widgets-tools/src/typings-generator/__tests__/outputs/systemtexts.ts b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/outputs/systemtexts.ts
new file mode 100644
index 00000000..334142ec
--- /dev/null
+++ b/packages/pluggable-widgets-tools/src/typings-generator/__tests__/outputs/systemtexts.ts
@@ -0,0 +1,45 @@
+export const systemTextsOutput = `/**
+ * This file was generated from MyWidget.xml
+ * WARNING: All changes made to this file will be overwritten
+ * @author Mendix Widgets Framework Team
+ */
+import { CSSProperties } from "react";
+
+export interface Translations {
+    "photo": [];
+    "photo_count": [params: [count: string]];
+    "mendix.textbox.TextBox": [key: "label" | "placeholder", params?: string[]]
+    "mendix.datagrid.DataGrid": [key: string, params?: string[]]
+}
+
+export interface MyWidgetContainerProps {
+    name: string;
+    class: string;
+    style?: CSSProperties;
+    tabIndex?: number;
+    texts: {
+        translate: <K extends keyof Translations>(key: K, ...params: Translations[K]) => string
+    }
+}
+
+export interface MyWidgetPreviewProps {
+    /**
+     * @deprecated Deprecated since version 9.18.0. Please use class property instead.
+     */
+    className: string;
+    class: string;
+    style: string;
+    styleObject?: CSSProperties;
+    readOnly: boolean;
+    renderMode: "design" | "xray" | "structure";
+    translate: (text: string) => string;
+}
+`;
+
+export const systemTextsNativeOutput = `export interface MyWidgetProps<Style> {
+    name: string;
+    style: Style[];
+    texts: {
+        translate: <K extends keyof Translations>(key: K, ...params: Translations[K]) => string
+    }
+}`;

From 9d62ea273e06624703d6d350175252193e18723c Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Fri, 3 Jul 2026 16:31:50 +0200
Subject: [PATCH 5/6] Add changelog entry for system texts

---
 packages/pluggable-widgets-tools/CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/pluggable-widgets-tools/CHANGELOG.md b/packages/pluggable-widgets-tools/CHANGELOG.md
index 16d89cdd..0dc92601 100644
--- a/packages/pluggable-widgets-tools/CHANGELOG.md
+++ b/packages/pluggable-widgets-tools/CHANGELOG.md
@@ -6,6 +6,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+### Added
+
+-   We added support for [System texts](https://docs.mendix.com/refguide/system-texts/), introduced to Pluggable Widgets in Mendix 11.13. Texts [defined in the Widget's XML file](https://docs.mendix.com/apidocs-mxsdk/apidocs/pluggable-widgets-property-types/#text) are included in Studio Pro's System text editor. Texts can be defined with parameters and default translations or can be a reference to an external System text.
+
 ## [11.12.0] - 2026-06-30
 
 ### Changed

From ed780427bf91175cb78cad0661b4464396e52838 Mon Sep 17 00:00:00 2001
From: Arjo Bruijnes <arjo.bruijnes@mendix.com>
Date: Fri, 3 Jul 2026 16:32:28 +0200
Subject: [PATCH 6/6] Bump version

---
 packages/pluggable-widgets-tools/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/pluggable-widgets-tools/package.json b/packages/pluggable-widgets-tools/package.json
index 8d83977c..1ac2098a 100644
--- a/packages/pluggable-widgets-tools/package.json
+++ b/packages/pluggable-widgets-tools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@mendix/pluggable-widgets-tools",
-  "version": "11.12.0",
+  "version": "11.13.0",
   "description": "Mendix Pluggable Widgets Tools",
   "engines": {
     "node": ">=20"