@combeenation/custom-code-sdk 0.0.1-alpha8 → 0.0.1-rc1

package/dist/index.d.ts

@@ -1,17 +1,145 @@
 import { z } from 'zod';
 
+declare const __brand: unique symbol;
+
+export declare function addButtonControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateButtonProperties>;
+}): Button;
+
+export declare function addCheckboxControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateCheckboxProperties>;
+}): Checkbox;
+
+export declare function addCollapsibleControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateCollapsibleProperties>;
+}): Collapsible;
+
+export declare function addComboboxControl<TMode extends ListMode, TValueType extends DataListValueType = never>(parent: ParentCtrl, options: {
+    mode: TMode;
+    position?: AddCtrlPosition;
+    /**
+     * When using properties of type `LiquidTemplateSource`, you have to manually cast the given `string` to
+     * `LiquidTemplateSource` like this:
+     *
+     * ```ts
+     * combobox.setProperty('dataTemplate', '<span>{{ Name }}</span>' as LiquidTemplateSource);
+     * ```
+     */
+    properties?: Partial<CreateComboboxProperties>;
+} & (TMode extends 'no-selection' ? {
+    valueType?: never;
+} : {
+    valueType: TValueType;
+})): Combobox<DataListValue_2<TMode, TValueType>>;
+
+declare type AddCtrlPosition = 'first' | 'last' | {
+    before: Ctrl;
+} | {
+    after: Ctrl;
+};
+
+export declare function addCustomControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateCustomCtrlProperties>;
+}): CustomControl;
+
+export declare function addDataviewControl<TMode extends ListMode, TValueType extends DataListValueType = never>(parent: ParentCtrl, options: {
+    mode: TMode;
+    position?: AddCtrlPosition;
+    /**
+     * When using properties of type `LiquidTemplateSource`, you have to manually cast the given `string` to
+     * `LiquidTemplateSource` like this:
+     *
+     * ```ts
+     * dataview.setProperty('dataTemplate', '<span>{{ Name }}</span>' as LiquidTemplateSource);
+     * ```
+     */
+    properties?: Partial<CreateDataviewProperties>;
+} & (TMode extends 'no-selection' ? {
+    valueType?: never;
+} : {
+    valueType: TValueType;
+})): Dataview<DataListValue_2<TMode, TValueType>>;
+
+export declare function addInputControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateInputProperties>;
+}): Input;
+
+export declare function addPanelControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreatePanelProperties>;
+}): Panel;
+
+export declare function addTextControl(parent: ParentCtrl, options?: {
+    position?: AddCtrlPosition;
+    properties?: Partial<CreateTextProperties>;
+}): Text_2;
+
+declare type AlignmentBlockOption = z.infer<typeof ZAlignmentBlockOption>;
+
 declare type AppLanguage = 'en' | 'de';
 
 declare type AssetName = z.infer<typeof ZAssetName>;
 
+/**
+ * Registers a callback which will be executed before the configurator is rendered.\
+ * The callback can be used to perform async operations that must be completed before the configurator is rendered.
+ *
+ * !!! Info !!!
+ *
+ * The callback must be registered in the synchronous top-level context of your main entry file.\
+ * The callback will have **no** effect when registered in any async context, i.e. after any `await` or inside some
+ * async callback function etc.
+ */
+export declare const beforeConfiguratorIsRendered: (callback: () => Promise<void>) => void;
+
+/**
+ * Give a type a distinct identity without changing its runtime representation.\
+ * E.g. when "branding" a simple string type, it must always be explicitly casted to the branded type.
+ *
+ * @see https://www.learningtypescript.com/articles/branded-types
+ * @see https://youtu.be/aP6w2OzidYM
+ *
+ * @example
+ * type userId = Brand<string, 'userId'>;
+ * const test = (id: userId) => {
+ *   console.log(id);
+ * };
+ *
+ * test('blah'); // error
+ * test('blah' as userId);
+ */
+declare type Brand<T, B extends string> = T & {
+    [__brand]: B;
+};
+
 export declare class Button {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLButtonElement>): CallbackUnsubscribeOption;
     onClick(callback: OnClickCallback): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
     setText(text: string): void;
+    /**
+     * Set arbitrary properties of the button control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link ButtonV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetButtonPropertyValue>(propertyName: T, value: SetButtonPropertyValue[T]): void;
 }
 
 declare type CallbackUnsubscribeOption = {
@@ -20,11 +148,22 @@ declare type CallbackUnsubscribeOption = {
 
 export declare namespace CbnSdk {
     export {
+        addButtonControl,
+        addCheckboxControl,
+        addCollapsibleControl,
+        addComboboxControl,
+        addCustomControl,
+        addDataviewControl,
+        addInputControl,
+        addPanelControl,
+        addTextControl,
+        beforeConfiguratorIsRendered,
         configuratorIsInIFrame,
         finishConfiguration,
         fireAnalyticsEvent,
         getAssetPaths,
         getParentPageUrl,
+        onParentPageEvent,
         navigateToLogin,
         onAnyCmpValueChanged,
         redirectParentPage,
@@ -32,16 +171,47 @@ export declare namespace CbnSdk {
         setConfiguratorIFrameSize,
         shareConfiguration,
         createSyncCmpValuesStore,
+        uploadFiles,
+        uploadImages,
+        uploadTempFiles,
+        uploadTempImages,
+        convertDocument,
+        createPdfFromAssets,
+        createArPage,
         version
     }
 }
 
+export declare type CfgnFileUploadData<T extends string = string> = {
+    [fileName in T]: {
+        file: FileOrDataUri;
+        displayName?: string;
+    };
+};
+
 export declare class Checkbox {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLLabelElement>): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
+    setChecked(checked: boolean): void;
+    onCheckedChange(callback: (checked: boolean) => void | Promise<void>): CallbackUnsubscribeOption;
+    /**
+     * Set arbitrary properties of the checkbox control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link CheckboxV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetCheckboxPropertyValue>(propertyName: T, value: SetCheckboxPropertyValue[T]): void;
 }
 
 declare type CmpName = string;
@@ -84,8 +254,149 @@ export declare class Collapsible {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
+    /**
+     * Set arbitrary properties of the collapsible control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link CollapsibleV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetCollapsiblePropertyValue>(propertyName: T, value: SetCollapsiblePropertyValue[T]): void;
+}
+
+export declare class Combobox<TValue extends NonNullable<DataListValue>> {
+    #private;
+    readonly id: CtrlId;
+    constructor(id: CtrlId);
+    /**
+     * See {@link CustomControlV1.onRendered} for detailed information on what you can do with this listener and what it
+     * is not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
+    onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
+    /**
+     * See {@link CustomControlV1.onRendered} for detailed information on what you can do with this listener and what it
+     * is not meant for. Most of the information there also applies to `onItemRendered`.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback which also applies here.
+     *
+     * @param callback Callback function which is given the rendered HTML element and the corresponding item data.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the combobox entries are populated:
+     *
+     *                 ```ts
+     *                 combobox.onItemRendered<IProductsTable[number]>((el, itemData) => { ... })
+     *                 ```
+     */
+    onItemRendered<TItemData>(callback: (element: HTMLDivElement, itemData: TItemData) => void): CallbackUnsubscribeOption;
+    /**
+     * See {@link CustomControlV1.onRendered} for detailed information on what you can do with this listener and what it
+     * is not meant for. Most of the information there also applies to `onValueItemRendered`.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback which also applies here.
+     *
+     * @param callback Callback function which is given the rendered HTML element and the corresponding item data of the
+     *                 currently selected value item shown in the trigger.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the combobox entries are populated:
+     *
+     *                 ```ts
+     *                 combobox.onValueItemRendered<IProductsTable[number]>((el, itemData) => { ... })
+     *                 ```
+     */
+    onValueItemRendered<TItemData>(callback: (element: HTMLDivElement, itemData: TItemData) => void): CallbackUnsubscribeOption;
+    /**
+     * See {@link CustomControlV1.onRendered} for detailed information on what you can do with this listener and what it
+     * is not meant for. Most of the information there also applies to `onGroupHeaderRendered`.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback which also applies here.
+     *
+     * @param callback Callback function which is given the rendered HTML element and the corresponding group data.
+     *
+     *                 Typical usage for type safe access to the group data where `IProductGroupsTable` is the auto
+     *                 generated type of the table component from which the combobox groups are populated:
+     *
+     *                 ```ts
+     *                 combobox.onGroupHeaderRendered<IProductGroupsTable[number]>((el, groupData) => { ... })
+     *                 ```
+     */
+    onGroupHeaderRendered<TGroupData>(callback: (element: HTMLDivElement, groupData: TGroupData) => void): CallbackUnsubscribeOption;
+    /**
+     * Fires when the selection is committed which is:
+     *   - in single select mode: when the popup closes (or when an option is clicked).
+     *   - in multi select mode: immediately on every selection change.
+     *
+     * @param callback Callback function which is given the raw selection value/keys and the corresponding item data of
+     *                 all the selected items.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the combobox entries are populated:
+     *
+     *                 ```ts
+     *                 // Single selection:
+     *                 combobox.onValueChange<IProductsTable[number]>((value, valueItemData) => { ... })
+     *
+     *                 // Multi selection:
+     *                 combobox.onValueChange<IProductsTable>((value, valueItemData) => { ... })
+     *                 ```
+     */
+    onValueChange<TItemData extends TValue extends any[] ? any[] : any>(callback: (value: TValue | undefined, valueItemData: TItemData | undefined) => void): CallbackUnsubscribeOption;
+    /**
+     * Registers a callback that fires when a combobox item is clicked.
+     *
+     * - Fires **before** `onValueChange`.
+     * - Fires even when the clicked item is already selected.
+     *
+     * @param callback Callback function which is given the item data of the clicked item and the raw mouse event.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the combobox entries are populated:
+     *
+     *                 ```ts
+     *                 combobox.onItemClicked<IProductsTable[number]>((itemData, event) => { ... })
+     *                 ```
+     */
+    onItemClicked<TItemData>(callback: (itemData: TItemData, event: MouseEvent) => void): CallbackUnsubscribeOption;
+    setVisible(visible: boolean): Promise<void>;
+    /**
+     * Sets the entries (data items) displayed by the combobox. Existing entries are overwritten.
+     */
+    setEntries(entries: TemplateData[]): void;
+    /**
+     * Sets the group data used to render the group headers of the combobox. Existing group data is overwritten.
+     */
+    setGroupData(groupData: TemplateData[]): void;
+    /**
+     * Set arbitrary properties of the combobox control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link ComboboxV1.setVisible} should be used instead.
+     *
+     * When using properties of type `LiquidTemplateSource`, you have to manually cast the given `string` to
+     * `LiquidTemplateSource` like this:
+     *
+     * ```ts
+     * combobox.setProperty('dataTemplate', '<span>{{ Name }}</span>' as LiquidTemplateSource);
+     * ```
+     */
+    setProperty<T extends keyof SetComboboxPropertyValue>(propertyName: T, value: SetComboboxPropertyValue[T]): void;
 }
 
 /**
@@ -93,6 +404,279 @@ export declare class Collapsible {
  */
 export declare const configuratorIsInIFrame: () => boolean;
 
+/**
+ * Create and convert a document (e.g. HTML to PDF).\
+ * The conversion consists of multiple individual tasks to allow full flexibility when creating documents.
+ *
+ * Example case: Create a PDF with dynamic content (PDF asset) and append a static product datasheet.
+ *
+ * See also {@link createPdfFromAssets} for a simplified version to create a PDF.
+ * @param tasks The tasks are executed based on their connection with the properties `name` and `inputTaskName`
+ *              (the order in the array is irrelevant)
+ * @returns     URL to the generated cfgn file, if successful
+ *
+ * @example
+ * ```ts
+ * const resultUrl = await convertDocument([
+ *   {
+ *     type: DocumentConvertTaskTypes.PdfAsset,
+ *     name: 'HtmlToPdfTask',
+ *     bundleAliasName: 'MyBundle',
+ *     assetPath: 'quotePdfAsset',
+ *     context: {
+ *       subject: 'MySubject',
+ *     },
+ *   },
+ *   {
+ *     type: DocumentConvertTaskTypes.OutputToCfgnFile,
+ *     name: 'OutputPdfTask',
+ *     inputTaskName: 'HtmlToPdfTask',
+ *     cfgnFileName: 'QuotePdf',
+ *     cfgnFileExtension: 'pdf',
+ *     cfgnFileDisplayName: `Your_quote_${new Date().toISOString()}`,
+ *   },
+ * ]);
+ * ```
+ */
+export declare const convertDocument: (tasks: DocumentConvertTask[]) => Promise<string | undefined>;
+
+/**
+ * Uploads the given GLB file to a peristent storage and creates a dedicated page with an AR viewer that loads the GLB.
+ *
+ * After successful creation, it either redirects to that page or shows a dialog with a QR code linking to that page.
+ *
+ * Whether it redirects or shows a dialog depends on the browsers capabilities to directly open AR experiences.
+ */
+export declare const createArPage: (glb: File, options?: SdkCreateArPageOptions) => Promise<void>;
+
+declare type CreateButtonProperties = {
+    text: string | undefined;
+    width: string | undefined;
+    height: string | undefined;
+    minWidth: string | undefined;
+    minHeight: string | undefined;
+    maxWidth: string | undefined;
+    maxHeight: string | undefined;
+    margin: string | undefined;
+    padding: string | undefined;
+    cssClasses: string[] | undefined;
+    backgroundNormal: string | undefined;
+    backgroundHover: string | undefined;
+    backgroundPressed: string | undefined;
+    borderRadius: string | undefined;
+    font: string | undefined;
+    color: string | undefined;
+    visible: boolean | undefined;
+    enabled: boolean | undefined;
+    tooltipText: string | undefined;
+    tooltipPos: ElementPosOption | undefined;
+    alignmentBlock: AlignmentBlockOption | undefined;
+};
+
+declare type CreateCheckboxProperties = {
+    checked: boolean | undefined;
+    captionPos: ElementPosOption | undefined;
+    captionText: string | undefined;
+    visible: boolean | undefined;
+    enabled: boolean | undefined;
+    minWidth: string | undefined;
+    minHeight: string | undefined;
+    maxWidth: string | undefined;
+    maxHeight: string | undefined;
+    margin: string | undefined;
+    padding: string | undefined;
+    font: string | undefined;
+    color: string | undefined;
+    backgroundNormal: string | undefined;
+    backgroundHover: string | undefined;
+    backgroundPressed: string | undefined;
+    borderRadius: string | undefined;
+    cssClasses: string[] | undefined;
+    tooltipText: string | undefined;
+    tooltipPos: ElementPosOption | undefined;
+};
+
+declare type CreateCollapsibleProperties = {
+    captionText: string | undefined;
+    collapsed: boolean | undefined;
+    group: string | undefined;
+    visible: boolean | undefined;
+    cssClasses: string[] | undefined;
+};
+
+declare type CreateComboboxProperties = {
+    value: string | undefined;
+    valueType: DataListValueType | undefined;
+    width: string | undefined;
+    minWidth: string | undefined;
+    maxWidth: string | undefined;
+    height: string | undefined;
+    minHeight: string | undefined;
+    maxHeight: string | undefined;
+    backgroundNormal: string | undefined;
+    margin: string | undefined;
+    padding: string | undefined;
+    borderRadius: string | undefined;
+    captionText: string | undefined;
+    captionPos: ElementPosOption | undefined;
+    cssClasses: string[] | undefined;
+    flexDirection: FlexDirection | undefined;
+    flexWrap: boolean | undefined;
+    gap: string | undefined;
+    visible: boolean | undefined;
+    enabled: boolean | undefined;
+    placeholder: string | undefined;
+    dataEntries: DataListEntries | undefined;
+    dataTemplate: LiquidTemplateSource | undefined;
+    valueTemplate: LiquidTemplateSource | undefined;
+    groupKey: string | undefined;
+    groupData: DataListGroupData | undefined;
+    groupTemplate: LiquidTemplateSource | undefined;
+    tooltipKey: string | undefined;
+    itemHiddenKey: string | undefined;
+    itemDisabledKey: string | undefined;
+    itemCssClassesKey: string | undefined;
+    filterable: boolean | undefined;
+    filterKey: string | undefined;
+    filterCaptionText: string | undefined;
+    filterPlaceholder: string | undefined;
+    listMode: ListMode | undefined;
+    clearable: boolean | undefined;
+};
+
+declare type CreateCustomCtrlProperties = {
+    customCodeControlled: boolean | undefined;
+    rawHtml: string | undefined;
+    visible: boolean | undefined;
+    cssClasses: string[] | undefined;
+};
+
+declare type CreateDataviewProperties = {
+    value: string | undefined;
+    valueType: DataListValueType | undefined;
+    dataEntries: DataListEntries | undefined;
+    cssClasses: string[] | undefined;
+    padding: string | undefined;
+    margin: string | undefined;
+    visible: boolean | undefined;
+    gap: string | undefined;
+    flexDirection: FlexDirection | undefined;
+    flexWrap: boolean | undefined;
+    dataTemplate: LiquidTemplateSource | undefined;
+    groupKey: string | undefined;
+    groupData: DataListGroupData | undefined;
+    groupTemplate: LiquidTemplateSource | undefined;
+    tooltipKey: string | undefined;
+    itemHiddenKey: string | undefined;
+    itemDisabledKey: string | undefined;
+    itemCssClassesKey: string | undefined;
+    filterable: boolean | undefined;
+    filterKey: string | undefined;
+    filterCaptionText: string | undefined;
+    filterPlaceholder: string | undefined;
+    listMode: ListMode | undefined;
+    allowDeselect: boolean | undefined;
+};
+
+declare type CreateInputProperties = {
+    value: string | undefined;
+    errorMsg: string | undefined;
+    description: string | undefined;
+    captionText: string | undefined;
+    captionPos: ElementPosOption | undefined;
+    captionWidth: string | undefined;
+    backgroundNormal: string | undefined;
+    borderRadius: string | undefined;
+    padding: string | undefined;
+    margin: string | undefined;
+    width: string | undefined;
+    height: string | undefined;
+    maxHeight: string | undefined;
+    maxWidth: string | undefined;
+    minHeight: string | undefined;
+    minWidth: string | undefined;
+    enabled: boolean | undefined;
+    visible: boolean | undefined;
+    cssClasses: string[] | undefined;
+    placeholder: string | undefined;
+};
+
+declare type CreatePanelProperties = {
+    margin: string | undefined;
+    width: string | undefined;
+    height: string | undefined;
+    minWidth: string | undefined;
+    minHeight: string | undefined;
+    maxWidth: string | undefined;
+    maxHeight: string | undefined;
+    padding: string | undefined;
+    flexDirection: FlexDirection | undefined;
+    flexGrow: string | undefined;
+    flexWrap: boolean | undefined;
+    alignmentBlock: AlignmentBlockOption | undefined;
+    gap: string | undefined;
+    cssClasses: string[] | undefined;
+    backgroundNormal: string | undefined;
+    visible: boolean | undefined;
+    enabled: boolean | undefined;
+    opacity: string | undefined;
+    border: string | undefined;
+    borderRadius: string | undefined;
+};
+
+/**
+ * Creates a PDF from one or more assets which will be merged in the given order.
+ *
+ * Simplified helper built on top of {@link convertDocument}.
+ * Use {@link convertDocument} directly for advanced scenarios.
+ *
+ * @param bundleAliasName     Bundle name where the assets are stored
+ * @param assetTasks          One or more "assets tasks" which will be merged in the given order
+ * @param cfgnFileName        Name of the generated cfgn file
+ * @param cfgnFileDisplayName Optional name which will be used when downloading the file
+ * @returns                   URL to the generated cfgn file, if successful
+ *
+ * @example
+ * ```ts
+ * const resultUrl = await createPdfFromAssets(
+ *  'MyBundle',
+ *  [
+ *    {
+ *      type: 'PdfAsset',
+ *      assetPath: 'quotePdfAsset',
+ *      context: {
+ *        subject: 'MySubject',
+ *      },
+ *    },
+ *    {
+ *      type: 'Asset',
+ *      assetPath: 'Pdf2',
+ *    },
+ *  ],
+ *  'QuotePdf',
+ *  `Your_quote_${new Date().toISOString()}`
+ * );
+ * ```
+ *
+ */
+export declare function createPdfFromAssets(bundleAliasName: string, assetTasks: CreatePdfTasks[], cfgnFileName: string, cfgnFileDisplayName?: string): Promise<string | undefined>;
+
+export declare type CreatePdfTasks = {
+    type: CreatePdfTaskTypes.PdfAsset;
+    assetPath: string;
+    context: object;
+} | {
+    type: CreatePdfTaskTypes.Asset;
+    assetPath: string;
+};
+
+export declare enum CreatePdfTaskTypes {
+    /** Create a PDF with dynamic content based on the given `context` */
+    PdfAsset = 0,
+    /** Static pdf asset (which is stored as File Asset) */
+    Asset = 1
+}
+
 /**
  * Creates a store holding component values which can be accessed synchronously.
  *
@@ -151,6 +735,32 @@ export declare const createSyncCmpValuesStore: <TCmps extends {
     [id: CmpName]: ValueComponent;
 }>(cmps: TCmps) => Promise<Readonly<SyncCmpValuesStore<TCmps>>>;
 
+declare type CreateTextProperties = {
+    text: string | undefined;
+    width: string | undefined;
+    height: string | undefined;
+    padding: string | undefined;
+    margin: string | undefined;
+    cssClasses: string[] | undefined;
+    visible: boolean | undefined;
+    tooltipText: string | undefined;
+    tooltipPos: ElementPosOption | undefined;
+    htmlTag: HtmlTagKind | undefined;
+    minWidth: string | undefined;
+    minHeight: string | undefined;
+    maxWidth: string | undefined;
+    maxHeight: string | undefined;
+    font: string | undefined;
+    color: string | undefined;
+    wrapText: boolean | undefined;
+    selfAlignmentBlock: AlignmentBlockOption | undefined;
+};
+
+/** Any control instance */
+declare type Ctrl = {
+    id: CtrlId;
+};
+
 declare type CtrlId = z.infer<typeof ZCtrlId>;
 
 export declare class CustomControl {
@@ -205,6 +815,10 @@ export declare class CustomControl {
      *
      * !!! Important !!!
      *
+     * See {@link OnRenderedCallback} for important information regarding the `element` which is passed to the callback.
+     *
+     * !!! Important !!!
+     *
      * This is **not** meant to be used for manipulating the rendered content of the control besides simple,
      * non-structural/-behavioral changes like adding CSS classes or data attributes etc.
      *
@@ -215,6 +829,14 @@ export declare class CustomControl {
     onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
     getElement(): HTMLElement | undefined;
     setVisible(visible: boolean): Promise<void>;
+    /**
+     * Set arbitrary properties of the custom control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link CustomControlV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetCustomCtrlPropertyValue>(propertyName: T, value: SetCustomCtrlPropertyValue[T]): void;
 }
 
 /**
@@ -223,14 +845,174 @@ export declare class CustomControl {
  */
 declare type CustomCtrlRenderFn = (element: HTMLDivElement, rawHtml: string | undefined) => void | Promise<void>;
 
-export declare class Dataview {
+declare type DataListEntries = z.infer<typeof ZDataListEntries>;
+
+declare type DataListGroupData = z.infer<typeof ZDataListGroupData>;
+
+/**
+ * The actual value which comes from the entries data and which is converted to `DataListHtmlValue` before being passed
+ * to the DOM elements.
+ */
+declare type DataListValue = string | string[] | number | number[] | undefined;
+
+declare type DataListValue_2<TMode extends ListMode, TValueType extends DataListValueType> = TMode extends 'no-selection' ? never : TMode extends 'single' ? TValueType : TValueType extends infer TBase ? TBase extends string | number ? TBase[] : never : never;
+
+declare type DataListValueType = z.infer<typeof ZDataListValueType>;
+
+export declare class Dataview<TValue extends NonNullable<DataListValue>> {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for. Most of the information there also applies to `onItemRendered`.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback which also applies here.
+     *
+     * @param callback Callback function which is given the rendered HTML element and the corresponding item data.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the dataview entries are populated:
+     *
+     *                 ```ts
+     *                 dataview.onItemRendered<IProductsTable[number]>(el, itemData) => { ... }
+     *                 ```
+     */
+    onItemRendered<TItemData>(callback: (element: HTMLDivElement, itemData: TItemData) => void): CallbackUnsubscribeOption;
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for. Most of the information there also applies to `onGroupHeaderRendered`.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback which also applies here.
+     *
+     * @param callback Callback function which is given the rendered HTML element and the corresponding group data.
+     *
+     *                 Typical usage for type safe access to the group data where `IProductGroupsTable` is the auto
+     *                 generated type of the table component from which the dataview groups are populated:
+     *
+     *                 ```ts
+     *                 dataview.onGroupHeaderRendered<IProductGroupsTable[number]>((el, groupData) => { ... })
+     *                 ```
+     */
+    onGroupHeaderRendered<TGroupData>(callback: (element: HTMLDivElement, groupData: TGroupData) => void): CallbackUnsubscribeOption;
+    /**
+     * @param callback Callback function which is given the raw selection value/keys and the corresponding item data of
+     *                 all the selected items.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the dataview entries are populated:
+     *
+     *                 ```ts
+     *                 // Single selection list:
+     *                 dataview.onValueChange<IProductsTable[number]>(value, valueItemData) => { ... }
+     *
+     *                 // Multi selection list:
+     *                 dataview.onValueChange<IProductsTable>(value, valueItemData) => { ... }
+     *                 ```
+     */
+    onValueChange<TItemData extends TValue extends any[] ? any[] : any>(callback: (value: TValue | undefined, valueItemData: TItemData | undefined) => void): CallbackUnsubscribeOption;
+    /**
+     * Registers a callback that fires when a datalist item is clicked.
+     *
+     * - Fires **before** `onValueChange`.
+     * - Fires even when the clicked item is already selected.
+     *
+     * @param callback Callback function which is given the item data of rendered item and the raw mouse event.
+     *
+     *                 Typical usage for type safe access to the item data where `IProductsTable` is the auto generated
+     *                 type of the table component from which the dataview entries are populated:
+     *
+     *                 ```ts
+     *                 dataview.onItemClicked<IProductsTable[number]>(itemData, event) => { ... }
+     *                 ```
+     */
+    onItemClicked<TItemData>(callback: (itemData: TItemData, event: MouseEvent) => void): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
+    /**
+     * Sets the entries (data items) displayed by the dataview. Existing entries are overwritten.
+     */
+    setEntries(entries: TemplateData[]): void;
+    /**
+     * Sets the group data used to render the group headers of the dataview. Existing group data is overwritten.
+     */
+    setGroupData(groupData: TemplateData[]): void;
+    /**
+     * Set arbitrary properties of the dataview control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link DataviewV1.setVisible} should be used instead.
+     *
+     * When using properties of type `LiquidTemplateSource`, you have to manually cast the given `string` to
+     * `LiquidTemplateSource` like this:
+     *
+     * ```ts
+     * dataview.setProperty('dataTemplate', '<span>{{ Name }}</span>' as LiquidTemplateSource);
+     * ```
+     */
+    setProperty<T extends keyof SetDataviewPropertyValue>(propertyName: T, value: SetDataviewPropertyValue[T]): void;
 }
 
+export declare type DocumentConvertTask = {
+    type: DocumentConvertTaskTypes.PdfAsset;
+    name: string;
+    /** Alias name, as set in the asset bundle assignment dialog */
+    bundleAliasName: string;
+    /** Dot seperated path, e.g. 'MyPDFFolder.MyPDFAsset' */
+    assetPath: string;
+    /** Custom object which must represent the context, as defined in the PDF asset */
+    context: object;
+} | {
+    type: DocumentConvertTaskTypes.Asset;
+    name: string;
+    /** Alias name, as set in the asset bundle assignment dialog */
+    bundleAliasName: string;
+    /** Dot seperated path, e.g. 'MyPDFFolder.MyStaticAsset' */
+    assetPath: string;
+} | {
+    type: DocumentConvertTaskTypes.Merge;
+    name: string;
+    /** Names of the tasks which should be merged in the given order */
+    inputTaskNames: string[];
+} | {
+    type: DocumentConvertTaskTypes.OutputToCfgnFile;
+    name: string;
+    inputTaskName: string;
+    /** Name of the generated cfgn file */
+    cfgnFileName: string;
+    cfgnFileExtension: string;
+    /** Optional name which will be used when downloading the file */
+    cfgnFileDisplayName?: string;
+};
+
+export declare enum DocumentConvertTaskTypes {
+    /** Create a PDF with dynamic content based on the given `context` */
+    PdfAsset = 0,
+    /** Retrieve an asset to be used for suceeding tasks (e.g. static PDF for merge) */
+    Asset = 1,
+    /** Merge multiple input tasks into a single document */
+    Merge = 2,
+    /** Finalize the conversion by storing it as `Configuration file` */
+    OutputToCfgnFile = 4
+}
+
+declare type ElementPosOption = z.infer<typeof ZElementPosOption>;
+
+declare type FileOrDataUri = File | {
+    dataUri: string;
+    extension: string;
+};
+
 /**
  * Creates a finish of the current configuration by running all the Configurator's finish actions and optionally passes
  * the resulting data to the parent page.
@@ -290,10 +1072,15 @@ declare type FinishConfigurationBaseOptions = {
  */
 export declare const fireAnalyticsEvent: (event: string, eventData?: object | string) => Promise<ParentPageComResult<void>>;
 
+export declare enum FlexDirection {
+    Column = 0,
+    Row = 1
+}
+
 export declare type FlexShopFinishJson = Shopware6FinishJson;
 
 /**
- * Returns the resolved 3D asset paths (babylon.js assets, material packs, texture image assets)
+ * Returns the resolved 3D asset paths (babylon.js assets, material assets, texture image assets)
  * for all pre-packed asset bundles configured for this Configurator.
  *
  * The result is fetched once and cached — subsequent calls resolve immediately from cache.
@@ -312,12 +1099,31 @@ export declare const getParentPageUrl: () => Promise<ParentPageComResult<{
     url: string;
 }>>;
 
+declare type HtmlTagKind = z.infer<typeof ZHtmlTagKind>;
+
 export declare class Input {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
+    setValue(value: string): void;
+    onValueChange(callback: (value: string) => void | Promise<void>): CallbackUnsubscribeOption;
+    /**
+     * Set arbitrary properties of the input control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link InputV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetInputPropertyValue>(propertyName: T, value: SetInputPropertyValue[T]): void;
 }
 
 declare type JsonArray = Array<SerializableJsonValue>;
@@ -329,11 +1135,17 @@ declare type JsonObject = {
 declare type JsonPrimitive = string | number | boolean | null;
 
 /**
- * Raw material JSON which can be passed to Babylon.js e.g. via `Material.Parse(material)`
+ * Template written in ["Liquid HTML"](https://liquidjs.com/tutorials/intro-to-liquid.html)).
+ * When rendering actual HTML from this, it is enriched by the `dataEntries`.
  */
-declare type MaterialAsset = z.infer<typeof ZMaterialAsset>;
+export declare type LiquidTemplateSource = Brand<string, 'LiquidTemplate'>;
 
-declare type MaterialPackName = z.infer<typeof ZMaterialPackName>;
+declare type ListMode = z.infer<typeof ZListMode>;
+
+/**
+ * Raw material JSON which can be passed to Babylon.js e.g. via `Material.Parse(material)`
+ */
+declare type MaterialObject = z.infer<typeof ZMaterialObject>;
 
 /**
  * Navigates to the login page of the Configurator.
@@ -383,16 +1195,68 @@ export declare const onAnyCmpValueChanged: <TInput extends ValueComponent>(liste
 
 declare type OnClickCallback = () => void;
 
+/**
+ * Registers a callback for events from the parent page.\
+ * The parent page can send those events by calling `Combeenation.sendEventToConfigurator`.
+ */
+export declare const onParentPageEvent: (callback: (type: "success" | "error", data: unknown) => void) => CallbackUnsubscribeOption;
+
+/**
+ * @param element The rendered DOM element.
+ *
+ *                !!! Important !!!
+ *
+ *                This can either be a newly created element or the same, reused element which was already passed to a
+ *                previous `onRendered` callback invocation.
+ *
+ *                What does this mean?
+ *                - When registering event listener, avoid `element.addEventListener` but use the form
+ *                  `element.onclick = ...` instead.
+ *                - Be careful when using API like `MutationObserver` on the element and ensure to not register multiple
+ *                  observer on the same element over time.
+ *                - Be careful when binding/using the element in external libraries which might use `addEventListener`
+ *                  or things like `MutationObserver` internally (e.g. DnD libraries etc.).
+ *                - If you **need to** use `addEventListener` etc. e.g. because you have to use a library which uses it
+ *                  internally, make sure to manually check whether the element was already processed/initialized in a
+ *                  previous `onRendered` invocation or not.
+ *
+ *                  E.g. something like this:
+ *
+ *                  ```ts
+ *                  dataview.onRendered((element) => {
+ *                    if (element.dataset.wasVisited) return;
+ *                    element.dataset.wasVisited = 'true';
+ *
+ *                    // -> Safely use `element.addEventListener` or `dndManager.init(element)` etc.
+ *                  });
+ */
 declare type OnRenderedCallback<T extends HTMLElement = HTMLElement> = (element: T) => void;
 
 export declare class Panel {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLDivElement>): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
+    /**
+     * Set arbitrary properties of the panel control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link PanelV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetPanelPropertyValue>(propertyName: T, value: SetPanelPropertyValue[T]): void;
 }
 
+declare type ParentCtrl = Panel | Collapsible;
+
 export declare type ParentPageCheckoutData = {
     /** Cfgn id */
     id: string;
@@ -471,18 +1335,49 @@ export declare const redirectParentPage: (url: string) => Promise<ParentPageComR
 
 declare type SdkAssetPaths = {
     babylonJsAssets: {
-        [key: AssetName]: Url;
+        [key: AssetName]: UrlString;
     };
-    materialPacks: {
-        [key: MaterialPackName]: {
-            [key: AssetName]: MaterialAsset;
-        };
+    materialAssets: {
+        [key: AssetName]: MaterialObject;
     };
     textureImageAssets: {
-        [key: AssetName]: Url;
+        [key: AssetName]: UrlString;
     };
 };
 
+/**
+ * `urls` contains a map of the uploaded files, where the key represents the name and the value the url.\
+ * It's recommended to check for the `success` flag beforehand.
+ */
+declare type SdkCfgnFileUploadResult<T extends string = string> = {
+    success: false;
+    urls?: never;
+} | {
+    success: true;
+    urls: {
+        [fileName in T]: string;
+    };
+};
+
+declare type SdkCfgnTempFileUploadResult = {
+    success: false;
+    urls?: never;
+} | {
+    success: true;
+    urls: string[];
+};
+
+declare type SdkCreateArPageOptions = {
+    qrSubTitle?: string;
+    qrDescription?: string;
+    preparationText?: string;
+    popupBlockedTitle?: string;
+    popupBlockedDescription?: string;
+    popupBlockedLinkText?: string;
+    environment?: UrlString;
+    loadingScreenImg?: UrlString;
+};
+
 /**
  * Send a custom message to the parent page via the "CustomMessage".\
  * The parent page can handle those messages by implementing the function `Combeenation.on{msgName}`.
@@ -495,6 +1390,14 @@ export declare const sendCustomMsgToParentPage: (msgName: string, data?: object)
 /** A JSON-serializable value safe to use as a `postMessage` payload etc. */
 declare type SerializableJsonValue = JsonPrimitive | JsonObject | JsonArray;
 
+declare type SetButtonPropertyValue = Omit<CreateButtonProperties, 'visible'>;
+
+declare type SetCheckboxPropertyValue = Omit<CreateCheckboxProperties, 'visible'>;
+
+declare type SetCollapsiblePropertyValue = Omit<CreateCollapsibleProperties, 'visible'>;
+
+declare type SetComboboxPropertyValue = Omit<CreateComboboxProperties, 'visible' | 'listMode' | 'valueType'>;
+
 /**
  * Changes the width and/or height of the IFrame and/or scroll position of the parent page window.
  *
@@ -513,6 +1416,16 @@ export declare const setConfiguratorIFrameSize: (data: {
     scrollToY?: number;
 }) => Promise<ParentPageComResult<void>>;
 
+declare type SetCustomCtrlPropertyValue = Omit<CreateCustomCtrlProperties, 'visible'>;
+
+declare type SetDataviewPropertyValue = Omit<CreateDataviewProperties, 'visible' | 'listMode' | 'valueType'>;
+
+declare type SetInputPropertyValue = Omit<CreateInputProperties, 'visible'>;
+
+declare type SetPanelPropertyValue = Omit<CreatePanelProperties, 'visible'>;
+
+declare type SetTextPropertyValue = Omit<CreateTextProperties, 'visible'>;
+
 /**
  * Creates a copy of the current configuration and opens a share window for the given platform with the resulting share
  * URL
@@ -640,17 +1553,88 @@ declare type SyncCmpValuesStore<TCmps extends Record<CmpName, ValueComponent>> =
     [K in keyof TCmps & CmpName]: TCmps[K] extends ValueComponent<any, infer TValue, any> ? TValue | undefined : never;
 };
 
+/**
+ * The raw data passed to the corresponding liquid template (e.g. to a datalist item template or a group header
+ * template etc.)
+ */
+declare type TemplateData = Record<string, unknown>;
+
 declare class Text_2 {
     #private;
     readonly id: CtrlId;
     constructor(id: CtrlId);
+    /**
+     * See {@link CustomControl.onRendered} for detailed information on what you can do with this listener and what it is
+     * not meant for.
+     *
+     * Also see {@link OnRenderedCallback} for important information regarding the `element` which is passed to the
+     * callback.
+     */
     onRendered(callback: OnRenderedCallback<HTMLSpanElement>): CallbackUnsubscribeOption;
     setVisible(visible: boolean): Promise<void>;
     setText(text: string): void;
+    /**
+     * Set arbitrary properties of the text control.\
+     * Behavior is the same as when setting the respective property in the configurator editor.
+     *
+     * Some properties are not allowed to be set here because they have a dedicated method which should be used instead.\
+     * E.g. setting `visible` is not allowed because {@link TextV1.setVisible} should be used instead.
+     */
+    setProperty<T extends keyof SetTextPropertyValue>(propertyName: T, value: SetTextPropertyValue[T]): void;
 }
 export { Text_2 as Text }
 
-declare type Url = z.infer<typeof ZUrl>;
+/**
+ * Upload one or more files into the current configuration
+ *
+ * Consider using {@link uploadTempFiles} if the files don't need to be persisted and
+ * aren't relevant for the finished configuration.
+ *
+ * @param files The key represents the name, which can be used in Hive with `configuration.GetFile("")`
+ * @returns An object with the same keys as the input. The values contain according result information.
+ */
+export declare const uploadFiles: <T extends string>(files: CfgnFileUploadData<T>) => Promise<SdkCfgnFileUploadResult<T>>;
+
+/**
+ * Upload one or more images into the current configuration.
+ *
+ * Consider using {@link uploadTempImages} if the images don't need to be persisted and
+ * aren't relevant for the finished configuration.
+ *
+ * @param images The key represents the name, which can be used in Hive with `configuration.GetImage("")`
+ * @returns An object with the same keys as the input. The values contain according result information.
+ */
+export declare const uploadImages: <T extends string>(images: CfgnFileUploadData<T>) => Promise<SdkCfgnFileUploadResult<T>>;
+
+/**
+ * Upload temporary files into the current configuration. This should only be used for files which don't need to be
+ * persisted or aren't relevant for the finished configuration.
+ * Examples:
+ *  - The user can upload multiple files but he still has to apply them on the product in a second step.
+ *    It's recommended to upload the files as temporary files and only upload them as cfgn files after they were
+ *    actually applied.
+ *
+ * @param files files to be uploaded
+ * @returns on success it returns the URLs of the uploaded files in the same order as they were provided.
+ */
+export declare const uploadTempFiles: (files: FileOrDataUri[]) => Promise<SdkCfgnTempFileUploadResult>;
+
+/**
+ * Upload temporary images into the current configuration. This should only be used for files which don't need to be
+ * persisted or aren't relevant for the finished configuration.
+ * Examples:
+ *  - When creating a PDF with screenshots of the 3d model, the images can be uploaded as temporary files, as they
+ *    will be embedded in the PDF.
+ *  - The user can upload multiple images but he still has to apply them on the product in a second step.
+ *    It's recommended to upload the images as temporary files and only upload them as cfgn files after they were
+ *    actually applied.
+ *
+ * @param images images to be uploaded
+ * @returns on success it returns the URLs of the uploaded images in the same order as they were provided.
+ */
+export declare const uploadTempImages: (images: FileOrDataUri[]) => Promise<SdkCfgnTempFileUploadResult>;
+
+declare type UrlString = z.infer<typeof ZUrlString>;
 
 /**
  * Represents a component of type `Value`
@@ -681,12 +1665,42 @@ export declare class ValueComponent<TName extends CmpName = CmpName, TValue exte
 
 export declare const version: string;
 
+declare const ZAlignmentBlockOption: z.ZodUnion<readonly [z.ZodLiteral<"topLeft">, z.ZodLiteral<"topCenter">, z.ZodLiteral<"topRight">, z.ZodLiteral<"centerLeft">, z.ZodLiteral<"centerCenter">, z.ZodLiteral<"centerRight">, z.ZodLiteral<"bottomLeft">, z.ZodLiteral<"bottomCenter">, z.ZodLiteral<"bottomRight">]>;
+
 declare const ZAssetName: z.ZodString;
 
-declare const ZCmpValue: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodUnknown]>;
+declare const ZCmpValue: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{}, z.core.$strip>, z.ZodUnknown]>;
 
 declare const ZCtrlId: z.ZodString;
 
+declare const ZDataListEntries: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+
+declare const ZDataListGroupData: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+
+/**
+ * !!! Note !!!
+ *
+ * We're relying on those values to be actual TS types which can be used in the generated typings for custom code as
+ * generics like `new Dataview<${valueType}>()`.
+ *
+ * Double check all consuming code if this ever changes (only `FlatCtrlMeta.typeGenerics` at the time of writing).
+ */
+declare const ZDataListValueType: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">]>;
+
+declare const ZElementPosOption: z.ZodUnion<readonly [z.ZodLiteral<"left">, z.ZodLiteral<"right">, z.ZodLiteral<"bottom">, z.ZodLiteral<"top">]>;
+
+declare const ZHtmlTagKind: z.ZodEnum<{
+    div: "div";
+    h1: "h1";
+    h2: "h2";
+    h3: "h3";
+    h4: "h4";
+    h5: "h5";
+    span: "span";
+}>;
+
+declare const ZListMode: z.ZodUnion<readonly [z.ZodLiteral<"single">, z.ZodLiteral<"multi">, z.ZodLiteral<"no-selection">]>;
+
 /**
  * Raw material JSON which can be passed to Babylon.js e.g. via `Material.Parse(material)`
  *
@@ -695,19 +1709,20 @@ declare const ZCtrlId: z.ZodString;
  *
  * Could be extended as needed.
  */
-declare const ZMaterialAsset: z.ZodObject<{
+declare const ZMaterialObject: z.ZodObject<{
     name: z.ZodString;
     id: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    name: z.ZodString;
-    id: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    name: z.ZodString;
-    id: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-
-declare const ZMaterialPackName: z.ZodString;
+    customType: z.ZodEnum<{
+        "BABYLON.PBRMaterial": "BABYLON.PBRMaterial";
+        "BABYLON.PBRMetallicRoughnessMaterial": "BABYLON.PBRMetallicRoughnessMaterial";
+        "BABYLON.PBRSpecularGlossinessMaterial": "BABYLON.PBRSpecularGlossinessMaterial";
+        "BABYLON.StandardMaterial": "BABYLON.StandardMaterial";
+        "BABYLON.BackgroundMaterial": "BABYLON.BackgroundMaterial";
+        "BABYLON.NodeMaterial": "BABYLON.NodeMaterial";
+    }>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
 
-declare const ZUrl: z.ZodBranded<z.ZodString, "Url">;
+declare const ZUrlString: z.core.$ZodBranded<z.ZodURL, "Url", "out">;
 
 export { }