From 7d467546cc5b676107fcde773493fc3f8e4645e7 Mon Sep 17 00:00:00 2001
From: Ilya Erokhin <ilya.erokhin@huawei.com>
Date: Wed, 23 Jul 2025 11:48:58 +0300
Subject: [PATCH] Regeneration v133 (based on e3cd9f6+2c6b0e99)

Signed-off-by: Ilya Erokhin <ilya.erokhin@huawei.com>
---
 arkoala-arkts/arkui-common/ets/ArkState.ts    |   571 +
 arkoala-arkts/arkui-common/ets/Storage.ts     |   895 +
 arkoala-arkts/arkui-common/ets/index.ts       |    17 +
 .../arkui/sdk/component/calendar.ets          |   265 +
 .../sdk/component/extendableComponent.ets     |     2 +-
 arkoala-arkts/arkui/sdk/generated/index.ets   |     1 +
 .../sdk/generated/ohos.app.ability.common.ets |     2 +-
 .../arkui/src/component/calendar.ets          |  2228 ++
 arkoala-arkts/arkui/src/component/common.ets  |  8062 ++---
 .../arkts/ArkUIGeneratedNativeModule.ets      |    60 +-
 .../arkui/src/generated/arkts/type_check.ets  |    53 +-
 arkoala-arkts/arkui/src/generated/index.ets   |     1 +
 .../src/generated/ohos.multimedia.image.ets   |     8 +-
 .../peers/CallbackDeserializeCall.ets         |    24 +-
 .../src/generated/peers/CallbackKind.ets      |     3 +
 .../arkui/src/generated/ts/type_check.ets     | 19836 +++++++++++
 .../native/src/generated/Serializers.h        | 28287 +++++++++-------
 .../src/generated/arkoala_api_generated.h     |   730 +-
 .../native/src/generated/bridge_generated.cc  |   316 +-
 .../generated/callback_deserialize_call.cc    |    40 +
 .../native/src/generated/callback_kind.h      |     2 +
 .../src/generated/callback_managed_caller.cc  |    44 +
 .../native/src/generated/dummy_impl.cc        |   420 +-
 .../native/src/generated/real_impl.cc         |   189 +-
 24 files changed, 44596 insertions(+), 17460 deletions(-)
 create mode 100644 arkoala-arkts/arkui-common/ets/ArkState.ts
 create mode 100644 arkoala-arkts/arkui-common/ets/Storage.ts
 create mode 100644 arkoala-arkts/arkui-common/ets/index.ts
 create mode 100644 arkoala-arkts/arkui/sdk/component/calendar.ets
 create mode 100644 arkoala-arkts/arkui/src/component/calendar.ets
 create mode 100644 arkoala-arkts/arkui/src/generated/ts/type_check.ets

diff --git a/arkoala-arkts/arkui-common/ets/ArkState.ts b/arkoala-arkts/arkui-common/ets/ArkState.ts
new file mode 100644
index 0000000000..ae8991a080
--- /dev/null
+++ b/arkoala-arkts/arkui-common/ets/ArkState.ts
@@ -0,0 +1,571 @@
+import { memo, memo_intrinsic, memo_entry, memo_stable, memo_skip } from "@koalaui/runtime/annotations"
+/*
+ * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { observableProxy, propDeepCopy } from "@koalaui/common"
+import { GlobalStateManager, MutableState, StateContext, __context, __id, mutableState, scheduleCallback } from "@koalaui/runtime"
+import { AbstractProperty, AppStorage, LocalStorage } from "./Storage"
+
+/**
+ * @param name - a name of a context state
+ * @param supplier - initial value supplier used on the state creation
+ * @returns a named state specified in the current context
+ * @internal
+ */
+@memo_intrinsic
+export function contextLocalStateOf<Value>(name: string, supplier: () => Value): MutableState<Value> {
+    return __context().namedState(name, () => observableProxy(supplier()))
+}
+
+/*
+    One-way synchronization
+ */
+export function propState<Value>(value?: Value): SyncedProperty<Value> {
+    return new SyncedProperty<Value>(value, true)
+}
+
+/*
+    Two-way synchronization
+ */
+export function objectLinkState<Value>(value?: Value): SyncedProperty<Value> {
+    return new SyncedProperty<Value>(value, false)
+}
+
+export class SyncedProperty<Value> /* implements MutableState<Value> */ {
+    private readonly deepCopyOnUpdate: boolean
+    private readonly state: MutableState<Value | undefined>
+    /*
+        _modified and _value needed for changes to be observable instantly, on the same recomputation value is being changed
+    */
+    private _modified = false
+    private _value?: Value
+
+    constructor(value: Value | undefined, deepCopyOnUpdate: boolean) {
+        /*
+            There is intentionally no observableProxy,
+            local initialization takes place when there is no synchronization with parent component
+        */
+        this.state = mutableState(value)
+        this.deepCopyOnUpdate = deepCopyOnUpdate
+    }
+
+    dispose() {
+        this.state.dispose()
+    }
+
+    get disposed(): boolean {
+        return this.state.disposed
+    }
+
+    get modified(): boolean {
+        return this.state.modified || this._modified
+    }
+
+    get value(): Value {
+        let value = this.state.value // subscribe
+        if (this._modified) value = this._value
+        return value!
+    }
+
+    set value(value: Value) {
+        this.state.value = value
+    }
+
+    @memo_intrinsic
+    update(value?: Value): void {
+        this._modified = false
+        this._value = undefined
+        if (value === undefined) return
+        this.state.value // subscribe to update
+        const scope = __context().scope<void>(__id(), 1)
+        const parameter = scope.param(0, value)
+        if (scope.unchanged) {
+            scope.cached
+            return
+        }
+        this._modified = true
+        parameter.value // subscribe to update
+        const updateValue = this.deepCopyOnUpdate ? observableProxy(propDeepCopy(value)) : value
+        this._value = updateValue
+        scheduleCallback(() => {
+            this.state.value = updateValue
+        })
+        scope.recache()
+    }
+}
+
+export class PlainStructProperty<Value> implements AbstractProperty<Value> {
+    private name: string
+    private value?: Value
+
+    constructor(name: string, value?: Value) {
+        this.name = name
+        this.value = value
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): Value {
+        return this.value!
+    }
+
+    set(value: Value): void {
+        this.value = value
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+    }
+}
+
+export class BuilderParamDecoratorProperty<Value> extends PlainStructProperty<Value> {
+    constructor(name: string, value?: Value) {
+        super(name, value)
+    }
+}
+
+export class LinkDecoratorProperty<Value> implements AbstractProperty<Value> {
+    private name: string
+    private property: AbstractProperty<Value>|undefined
+
+    constructor(name: string) {
+        this.name = name
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): Value {
+        return this.property!.get()
+    }
+
+    set(value: Value): void {
+        this.property!.set(value)
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+    }
+
+    provide(property: AbstractProperty<Value>): void {
+        this.property = property
+    }
+}
+
+export class StateDecoratorProperty<Value> implements AbstractProperty<Value>  {
+    protected name: string
+    protected state: MutableState<Value|undefined>
+    constructor(name: string, value?: Value) {
+        this.name = name
+        this.state = mutableState<Value|undefined>(value)
+    }
+    info(): string {
+        return this.name
+    }
+    get(): Value {
+        let value = this.state.value
+        return value!
+    }
+    set(value: Value): void {
+        this.state.value = value
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+    }
+}
+
+export class PropDecoratorProperty<Value> extends StateDecoratorProperty<Value> {
+    private value: Value | undefined = undefined
+    private deepcopy: boolean
+
+    constructor(name: string, deepcopy: boolean = true) {
+        super(name)
+        this.deepcopy = deepcopy
+    }
+
+    override get(): Value {
+        const state = super.get()
+        const value = this.value
+        return value ? value : state
+    }
+
+    override set(value: Value): void {
+        super.set(value)
+        this.value = undefined
+    }
+
+    @memo_intrinsic
+    update(value?: Value): void {
+        this.value = undefined
+        if (value === undefined) return
+        super.get() // subscribe to update
+        const scope = __context().scope<undefined>(__id(), 1)
+        const parameter = scope.param<Value>(0, value)
+        if (scope.unchanged) {
+            scope.cached
+            return
+        }
+        parameter.value // subscribe to update
+        this.value = observableProxy(this.deepcopy ? propDeepCopy(value) : value)
+        scheduleCallback(() => {
+            const value = this.value
+            if (value) this.set(value)
+        })
+        scope.recache()
+    }
+}
+
+export class ObjectLinkDecoratorProperty<Value> extends PropDecoratorProperty<Value> {
+    constructor(name: string) {
+        super(name, false)
+    }
+}
+
+export class ProvideDecoratorProperty<Value> extends StateDecoratorProperty<Value> {
+    private provideName: string
+    constructor(provideName: string, name: string, value?: Value) {
+        super(name, value)
+        this.provideName = provideName
+    }
+    provide(context: Object): void {
+        (context as StateContext).namedState<AbstractProperty<Value>>(this.provideName, () => this)
+    }
+    info(): string {
+        return this.name
+    }
+    get(): Value {
+        let value = this.state.value
+        return value!
+    }
+    set(value: Value): void {
+        this.state.value = value
+    }
+}
+
+export class ConsumeDecoratorProperty<Value> implements AbstractProperty<Value> {
+    private provideName: string
+    private name: string
+    private property: AbstractProperty<Value>|undefined
+
+    constructor(provideName: string, name: string) {
+        this.provideName = provideName
+        this.name = name
+        this.property = undefined
+    }
+    consume(context: Object): void {
+        this.property = (context as StateContext).valueBy<AbstractProperty<Value>>(this.provideName)
+    }
+    info(): string {
+        return this.name
+    }
+    get(): Value {
+        return this.property!.get()
+    }
+    set(value: Value): void {
+        this.property!.set(value)
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+    }
+}
+
+export class StorageLinkDecoratorProperty<Value> extends LinkDecoratorProperty<Value> {
+    constructor(name: string) {
+        super(name) // TODO: get state from app-storage
+    }
+}
+
+export class LocalStorageLinkDecoratorProperty<Value> extends LinkDecoratorProperty<Value> {
+    constructor(name: string) {
+        super(name) // TODO: get state from local-storage
+    }
+}
+
+export class StoragePropDecoratorProperty<Value> extends LinkDecoratorProperty<Value> {
+    constructor(name: string) {
+        super(name) // TODO: get state from app-storage
+    }
+}
+
+export class LocalStoragePropDecoratorProperty<Value> extends LinkDecoratorProperty<Value> {
+    constructor(name: string) {
+        super(name) // TODO: get state from local-storage
+    }
+}
+
+/**
+ * This interface represents a named property of a structure
+ * that must be initialized to the expected value before its first use.
+ */
+export interface StructProperty<Value> extends AbstractProperty<Value> {
+    applyInitialValue(value: Value): void
+}
+
+export interface LinkStructProperty<Value> extends AbstractProperty<Value> {
+    /**
+     * This method should be called during the struct initialization
+     * to link this named property with the property of a parent struct.
+     */
+    linkParentProperty(property: AbstractProperty<Value>): void
+}
+
+export interface ProvideStructProperty<Value> extends AbstractProperty<Value> {
+    /**
+     * This method should be called in very beginning of the builder function
+     * to provide this named property to all children.
+     */
+    provide(): void
+}
+
+export interface PropStructProperty<Value> extends StructProperty<Value> {
+    /**
+     * This method should be called in very beginning of the builder function
+     * to synchronize this named property with the parent property if it is changed.
+     */
+    @memo
+    syncValue(value?: Value): void
+}
+
+export function propertyForState<Value>(name: string, value: Value): StructProperty<Value> {
+    const property = new StateBasedPropertyImpl<Value>(name)
+    property.applyInitialValue(value)
+    return property
+}
+
+export function propertyForProp<Value>(name: string, value?: Value): PropStructProperty<Value> {
+    const property = new UpdatablePropertyImpl<Value>(name, true)
+    if (value) property.applyInitialValue(value)
+    return property
+}
+
+export function propertyForLink<Value>(name: string): LinkStructProperty<Value> {
+    return new LinkStructPropertyImpl<Value>(name)
+}
+
+export function propertyForObjectLink<Value>(name: string): PropStructProperty<Value> {
+    return new UpdatablePropertyImpl<Value>(name, false)
+}
+
+export function propertyForProvide<Value>(name: string, value: Value, key?: string): ProvideStructProperty<Value> {
+    const property = new ProvideStructPropertyImpl<Value>(name, key ?? name)
+    property.applyInitialValue(value)
+    return property
+}
+
+export function propertyForConsume<Value>(name: string, key?: string): AbstractProperty<Value> {
+    const property = new LinkStructPropertyImpl<Value>(name)
+    property.linkParentProperty(GlobalStateManager.instance.valueBy<AbstractProperty<Value>>(key ?? name))
+    return property
+}
+
+export function propertyForStorageLink<Value>(name: string, key: string, value: Value): AbstractProperty<Value> {
+    return new StorageBasedPropertyImpl<Value>(name, AppStorage.setAndLink(key, value))
+}
+
+export function propertyForLocalStorageLink<Value>(name: string, key: string, value: Value, storage: LocalStorage): AbstractProperty<Value> {
+    return new StorageBasedPropertyImpl<Value>(name, storage.setAndLink(key, value))
+}
+
+export function propertyForStorageProp<Value>(name: string, key: string, value: Value): AbstractProperty<Value> {
+    return new StorageBasedPropertyImpl<Value>(name, AppStorage.setAndProp(key, value))
+}
+
+export function propertyForLocalStorageProp<Value>(name: string, key: string, value: Value, storage: LocalStorage): AbstractProperty<Value> {
+    return new StorageBasedPropertyImpl<Value>(name, storage.setAndProp(key, value))
+}
+
+export function propertyForBuilderParam<Value>(name: string, value: Value): StructProperty<Value> {
+    const property = new ValueBasedPropertyImpl<Value>(name)
+    property.applyInitialValue(value)
+    return property
+}
+
+export function propertyUntrackable<Value>(name: string, value: Value): StructProperty<Value> {
+    const property = new ValueBasedPropertyImpl<Value>(name)
+    property.applyInitialValue(value)
+    return property
+}
+
+class ValueBasedPropertyImpl<Value> implements StructProperty<Value> {
+    private value: Value | undefined = undefined
+    private readonly name: string
+
+    constructor(name: string) {
+        this.name = name
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): Value {
+        return this.value as Value
+    }
+
+    set(value: Value) {
+        this.value = value
+    }
+
+    applyInitialValue(value: Value) {
+        this.value = value
+    }
+}
+
+class LinkStructPropertyImpl<Value> implements LinkStructProperty<Value> {
+    private property: AbstractProperty<Value> | undefined = undefined
+    private readonly name: string
+
+    constructor(name: string) {
+        this.name = name
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): Value {
+        return this.property!.get()
+    }
+
+    set(value: Value) {
+        this.property!.set(observableProxy(value))
+    }
+
+    linkParentProperty(property: AbstractProperty<Value>) {
+        this.property = property
+    }
+}
+
+class StorageBasedPropertyImpl<Value> extends LinkStructPropertyImpl<Value> {
+    constructor(name: string, property: AbstractProperty<Value>) {
+        super(name)
+        this.linkParentProperty(property)
+    }
+}
+
+class StateBasedPropertyImpl<Value> implements StructProperty<Value> {
+    private state: MutableState<Value> | undefined = undefined
+    private readonly name: string
+
+    constructor(name: string) {
+        this.name = name
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): Value {
+        return this.state!.value
+    }
+
+    set(value: Value) {
+        this.state!.value = observableProxy(value)
+    }
+
+    applyState(state: MutableState<Value>) {
+        this.state = state
+    }
+
+    applyInitialValue(value: Value) {
+        this.applyState(mutableState(observableProxy(value)))
+    }
+}
+
+class ProvideStructPropertyImpl<Value> extends StateBasedPropertyImpl<Value> implements ProvideStructProperty<Value> {
+    private readonly key: string
+
+    constructor(name: string, key: string) {
+        super(name)
+        this.key = key
+    }
+
+    provide() {
+        GlobalStateManager.instance.namedState<AbstractProperty<Value>>(this.key, () => this)
+    }
+}
+
+class UpdatablePropertyImpl<Value> extends StateBasedPropertyImpl<Value> implements PropStructProperty<Value> {
+    private value: Value | undefined = undefined
+    private readonly deepcopy: boolean
+
+    constructor(name: string, deepcopy: boolean) {
+        super(name)
+        this.deepcopy = deepcopy
+    }
+
+    private copy(value: Value): Value {
+        return observableProxy(this.deepcopy ? propDeepCopy(value) : value)
+    }
+
+    override get(): Value {
+        const state = super.get()
+        const value = this.value
+        return value ? value : state
+    }
+
+    override set(value: Value) {
+        super.set(value)
+        this.value = undefined
+    }
+
+    override applyInitialValue(value: Value) {
+        this.applyState(mutableState(this.copy(value)))
+    }
+
+    @memo_intrinsic
+    syncValue(value?: Value) {
+        this.value = undefined
+        if (value === undefined) return
+        super.get() // subscribe to update
+        const scope = __context().scope<undefined>(__id(), 1)
+        const parameter = scope.param<Value>(0, value)
+        if (scope.unchanged) {
+            scope.cached
+            return
+        }
+        this.value = this.copy(parameter.value)
+        scheduleCallback(() => {
+            const value = this.value
+            if (value) this.set(value)
+        })
+        scope.recache()
+    }
+}
diff --git a/arkoala-arkts/arkui-common/ets/Storage.ts b/arkoala-arkts/arkui-common/ets/Storage.ts
new file mode 100644
index 0000000000..ea378ccaf1
--- /dev/null
+++ b/arkoala-arkts/arkui-common/ets/Storage.ts
@@ -0,0 +1,895 @@
+/*
+ * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Disposable, GlobalStateManager, MutableState } from "@koalaui/runtime"
+
+/**
+ * @param storage - a local storage associated with an entry
+ * @param name - a state name in the specified storage
+ * @param value - a default value used to create a state if it is absent
+ * @returns a global named state from the specified storage
+ */
+export function StorageLinkState<Value>(storage: LocalStorage, name: string, value: Value): MutableState<Value> {
+    return storage.map.entryOrCreate(name, value).state
+}
+
+/**
+ * @param name - a state name in the application-based storage
+ * @param value - a default value used to create a state if it is absent
+ * @returns a global named state from the application-based storage
+ */
+export function AppStorageLinkState<Value>(name: string, value: Value): MutableState<Value> {
+    return StorageMap.shared.entryOrCreate(name, value).state
+}
+
+///// ArkUI ///// see common_ts_ets_api.d.ts /////
+
+/**
+ * Defines the AppStorage interface.
+ * @since 7
+ */
+export class AppStorage {
+    /**
+     * Returns an alias to the AppStorage property with given name.
+     * @param propName - a property name
+     * @returns an AbstractProperty by the given name, or `undefined` if it does not exist
+     */
+    static ref<T>(propName: string): AbstractProperty<T> | undefined {
+        return StorageMap.shared.entry<T>(propName)
+    }
+
+    /**
+     * Returns an alias to the AppStorage property with given name.
+     * If property does not exist in AppStorage, create it with the given value.
+     * @param propName - a property name
+     * @param defaultValue - a value used to create property if it does not exist
+     * @returns an AbstractProperty for the given name
+     */
+    static setAndRef<T>(propName: string, defaultValue: T): AbstractProperty<T> {
+        return StorageMap.shared.entryOrCreate(propName, defaultValue)
+    }
+
+    /**
+     * Called when a link is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Link<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return AppStorage.link<T>(propName)
+    }
+    /**
+     * Called when a link is set.
+     * @since 10
+     */
+    static link<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return StorageMap.shared.link<T>(propName)
+    }
+
+    /**
+     * Called when a hyperlink is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return AppStorage.setAndLink(propName, defaultValue)
+    }
+    /**
+     * Called when a hyperlink is set.
+     * @since 10
+     */
+    static setAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return StorageMap.shared.setAndLink(propName, defaultValue)
+    }
+
+    /**
+     * Called when a property is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Prop<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return AppStorage.prop<T>(propName)
+    }
+    /**
+     * Called when a property is set.
+     * @since 10
+     */
+    static prop<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return StorageMap.shared.prop<T>(propName)
+    }
+
+    /**
+     * Called when dynamic properties are set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetAndProp<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return AppStorage.setAndProp(propName, defaultValue)
+    }
+    /**
+     * Called when dynamic properties are set.
+     * @since 10
+     */
+    static setAndProp<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return StorageMap.shared.setAndProp(propName, defaultValue)
+    }
+
+    /**
+     * Called when owning or not.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Has(propName: string): boolean {
+        return AppStorage.has(propName)
+    }
+    /**
+     * Called when owning or not.
+     * @since 10
+     */
+    static has(propName: string): boolean {
+        return StorageMap.shared.has(propName)
+    }
+
+    /**
+     * Called when data is obtained.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Get<T>(propName: string): T | undefined {
+        return AppStorage.get<T>(propName)
+    }
+    /**
+     * Called when data is obtained.
+     * @since 10
+     */
+    static get<T>(propName: string): T | undefined {
+        return StorageMap.shared.get<T>(propName)
+    }
+
+    /**
+     * Called when setting.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Set<T>(propName: string, newValue: T): boolean {
+        return AppStorage.set(propName, newValue)
+    }
+    /**
+     * Called when setting.
+     * @since 10
+     */
+    static set<T>(propName: string, newValue: T): boolean {
+        return StorageMap.shared.set(propName, newValue, false)
+    }
+
+    /**
+     * Called when setting or creating.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetOrCreate<T>(propName: string, newValue: T): void {
+        AppStorage.setOrCreate(propName, newValue)
+    }
+    /**
+     * Called when setting or creating.
+     * @since 10
+     */
+    static setOrCreate<T>(propName: string, newValue: T): void {
+        StorageMap.shared.set(propName, newValue, true)
+    }
+
+    /**
+     * Called when a deletion is made.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Delete(propName: string): boolean {
+        return AppStorage.delete(propName)
+    }
+    /**
+     * Called when a deletion is made.
+     * @since 10
+     */
+    static delete(propName: string): boolean {
+        return StorageMap.shared.delete(propName)
+    }
+
+    /**
+     * Called when a dictionary is sorted.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Keys(): IterableIterator<string> {
+        return AppStorage.keys()
+    }
+    /**
+     * Called when a dictionary is sorted.
+     * @since 10
+     */
+    static keys(): IterableIterator<string> {
+        return StorageMap.shared.keys()
+    }
+
+    /**
+     * Called when a cleanup occurs.
+     * @since 7
+     * @deprecated since 9
+     * @useinstead AppStorage.Clear
+     */
+    static staticClear(): boolean {
+        return AppStorage.clear()
+    }
+
+    /**
+     * Called when a cleanup occurs.
+     * @since 9
+     * @deprecated since 10
+     */
+    static Clear(): boolean {
+        return AppStorage.clear()
+    }
+    /**
+     * Called when a cleanup occurs.
+     * @since 10
+     */
+    static clear(): boolean {
+        return StorageMap.shared.clear()
+    }
+
+    /**
+     * Called when the data can be changed.
+     * @since 7
+     */
+    static IsMutable(propName: string): boolean {
+        return StorageMap.shared.map.get(propName)?.mutable ?? false
+    }
+
+    /**
+     * Called when you check how much data is stored.
+     * @since 7
+     */
+    static Size(): number {
+        return AppStorage.size()
+    }
+    /**
+     * Called when you check how much data is stored.
+     * @since 10
+     */
+    static size(): number {
+        return StorageMap.shared.size
+    }
+}
+
+/**
+ *  AbstractProperty is an alias to the referenced storage property.
+ */
+export interface AbstractProperty<T> {
+    /**
+     * @returns the name of the referenced storage property
+     */
+    info(): string
+    /**
+     * @returns the value of the referenced storage property
+     */
+    get(): T
+    /**
+     * Updates the value of the referenced storage property.
+     * @param newValue - new value for the referenced storage property
+     */
+    set(newValue: T): void
+}
+
+/**
+ * Defines the subscribed abstract property.
+ * @since 7
+ * @systemapi
+ */
+export abstract class SubscribedAbstractProperty<T> implements AbstractProperty<T> {
+    /**
+     * Returns the property name,
+     * e.g. let link = AppStorage.Link("foo") then link.info() == "foo"
+     *
+     * @returns { string } the property name if set or undefined
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    abstract info(): string
+
+    /**
+     * Called when data is obtained.
+     * @since 7
+     * @systemapi
+     */
+    abstract get(): T
+
+    /**
+     * Called when data is created.
+     * @since 7
+     * @systemapi
+     */
+    abstract set(newValue: T): void
+
+    /**
+     * An app needs to call this function before the instance of SubscribedAbstractProperty
+     * goes out of scope / is subject to garbage collection. Its purpose is to unregister the
+     * variable from the two-way/one-way sync relationship that AppStorage/LocalStorage.link()/prop()
+     * and related functions create.
+     *
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    abstract aboutToBeDeleted(): void
+}
+
+/**
+ * EnvProps object
+ *
+ * @interface EnvPropsOptions
+ * @syscap SystemCapability.ArkUI.ArkUI.Full
+ * @crossplatform
+ * @since 10
+ */
+interface EnvPropsOptions {
+    /**
+     * Property name
+     *
+     * @type { string }
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    key: string;
+    /**
+     * DefaultValue is the default value if cannot get the environment property value
+     *
+     * @type { number | string | boolean }
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    defaultValue: number | string | boolean;
+}
+
+
+/**
+ * Defines the Environment interface.
+ * @since 7
+ */
+export class Environment {
+    /**
+     * Called when a property value is checked.
+     * @since 7
+     * @deprecated since 10
+     */
+    static EnvProp<T>(key: string, value: T): boolean {
+        return Environment.envProp(key, value)
+    }
+    /**
+     * Called when a property value is checked.
+     * @since 10
+     */
+    static envProp<T>(key: string, value: T): boolean {
+        throw new Error("Environment.EnvProp is not implemented")
+    }
+
+    /**
+     * Called when multiple property values are checked.
+     * @since 10
+     */
+    static envProps(props: EnvPropsOptions[]): void {
+        for (const prop of props) Environment.envProp(prop.key, prop.defaultValue)
+    }
+
+    /**
+     * Set the key value.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Keys(): Array<string> {
+        return Environment.keys()
+    }
+    /**
+     * Set the key value.
+     * @since 10
+     */
+    static keys(): Array<string> {
+        throw new Error("Environment.Keys is not implemented")
+    }
+}
+
+/**
+ * PersistProps object
+ *
+ * @interface PersistPropsOptions
+ * @syscap SystemCapability.ArkUI.ArkUI.Full
+ * @crossplatform
+ * @since 10
+ */
+declare interface PersistPropsOptions {
+    /**
+     * Property name
+     *
+     * @type { string }
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    key: string;
+    /**
+     * If AppStorage does not include this property it will be initialized with this value
+     *
+     * @type { number | string | boolean | Object }
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    defaultValue: number | string | boolean | Object;
+}
+
+/**
+ * Defines the PersistentStorage interface.
+ * @since 7
+ */
+export class PersistentStorage {
+    /**
+     * Called when a persistence property is stored.
+     * @since 7
+     * @deprecated since 10
+     */
+    static PersistProp<T>(key: string, defaultValue: T): void {
+        PersistentStorage.persistProp(key, defaultValue)
+    }
+    /**
+     * Called when a persistence property is stored.
+     * @since 10
+     */
+    static persistProp<T>(key: string, defaultValue: T): void {
+        throw new Error("PersistentStorage.persistProp is not implemented")
+    }
+
+    /**
+     * Called when a property is deleted.
+     * @since 7
+     * @deprecated since 10
+     */
+    static DeleteProp(key: string): void {
+        PersistentStorage.deleteProp(key)
+    }
+    /**
+     * Called when a property is deleted.
+     * @since 10
+     */
+    static deleteProp(key: string): void {
+        throw new Error("PersistentStorage.deleteProp is not implemented")
+    }
+
+    /**
+     * Called when multiple persistence properties are stored.
+     * @since 10
+     */
+    static persistProps(properties: PersistPropsOptions[]): void {
+        for (const prop of properties) PersistentStorage.persistProp(prop.key, prop.defaultValue)
+    }
+
+    /**
+     * Set the key value.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Keys(): Array<string> {
+        return PersistentStorage.keys()
+    }
+    /**
+     * Set the key value.
+     * @since 10
+     */
+    static keys(): Array<string> {
+        throw new Error("PersistentStorage.keys is not implemented")
+    }
+}
+
+/**
+ * Define LocalStorage.
+ * @since 9
+ */
+export class LocalStorage {
+    private static shared?: LocalStorage
+    /** @internal */ readonly map: StorageMap
+
+    /**
+     * Constructor.
+     * @since 9
+     */
+    constructor(initializingProperties?: IterableIterator<[string, Object]>) {
+        this.map = new StorageMap(initializingProperties)
+    }
+
+    /**
+     * Get current LocalStorage shared from stage.
+     * @StageModelOnly
+     * @since 9
+     * @deprecated since 10
+     */
+    static GetShared(): LocalStorage {
+        return LocalStorage.getShared()
+    }
+    /**
+     * Get current LocalStorage shared from stage.
+     * @StageModelOnly
+     * @since 10
+     */
+    static getShared(): LocalStorage {
+        let shared = LocalStorage.shared
+        if (shared) return shared
+        LocalStorage.shared = shared = new LocalStorage()
+        return shared
+    }
+
+    /**
+     * Return true if property with given name exists
+     * @since 9
+     */
+    has(propName: string): boolean {
+        return this.map.has(propName)
+    }
+
+    /**
+     * Return a Map Iterator
+     * @since 9
+     */
+    keys(): IterableIterator<string> {
+        return this.map.keys()
+    }
+
+    /**
+     * Return number of properties
+     * @since 9
+     */
+    size(): number {
+        return this.map.size
+    }
+
+    /**
+     * Return value of given property
+     * @since 9
+     */
+    get<T>(propName: string): T | undefined {
+        return this.map.get<T>(propName)
+    }
+
+    /**
+     * Set value of given property
+     * @since 9
+     */
+    set<T>(propName: string, newValue: T): boolean {
+        return this.map.set(propName, newValue, false)
+    }
+
+    /**
+     * Add property if not property with given name
+     * @since 9
+     */
+    setOrCreate<T>(propName: string, newValue: T): boolean {
+        this.map.set(propName, newValue, true)
+        return newValue != undefined
+    }
+
+    /**
+     * Returns an alias to the LocalStorage property with given name.
+     * @param propName - a property name
+     * @returns an AbstractProperty by the given name, or `undefined` if it does not exist
+     */
+    public ref<T>(propName: string): AbstractProperty<T> | undefined {
+        return this.map.entry<T>(propName)
+    }
+
+    /**
+     * Returns an alias to the LocalStorage property with given name.
+     * If property does not exist in LocalStorage, create it with the given value.
+     * @param propName - a property name
+     * @param defaultValue - a value used to create property if it does not exist
+     * @returns an AbstractProperty for the given name
+     */
+    setAndRef<T>(propName: string, defaultValue: T): AbstractProperty<T> {
+        return this.map.entryOrCreate(propName, defaultValue)
+    }
+
+    /**
+     * Create and return a 'link' (two-way sync) to named property
+     * @since 9
+     */
+    link<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return this.map.link<T>(propName)
+    }
+
+    /**
+     * Like link(), will create and initialize a new source property in LocalStorge if missing
+     * @since 9
+     */
+    setAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return this.map.setAndLink(propName, defaultValue)
+    }
+
+    /**
+     * Create and return a 'prop' (one-way sync) to named property
+     * @since 9
+     */
+    prop<T>(propName: string): SubscribedAbstractProperty<T> | undefined {
+        return this.map.prop<T>(propName)
+    }
+
+    /**
+     * Like prop(), will create and initialize a new source property in LocalStorage if missing
+     * @since 9
+     */
+    setAndProp<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return this.map.setAndProp(propName, defaultValue)
+    }
+
+    /**
+     * Delete property from StorageBase
+     * @since 9
+     * @returns false if method failed
+     */
+    delete(propName: string): boolean {
+        return this.map.delete(propName)
+    }
+
+    /**
+     * Delete all properties from the StorageBase
+     * @since 9
+     */
+    clear(): boolean {
+        return this.map.clear()
+    }
+}
+
+///// interface without generic types to workaround issues with ArkTS compiler /////
+
+interface EntryObject extends Disposable {
+    /*readonly*/ mutable: boolean
+}
+
+//////////////////////////////////////////////////
+
+class StorageEntry<T> implements EntryObject, AbstractProperty<T> {
+    readonly state: MutableState<T>
+    /*readonly*/ mutable: boolean
+    readonly name: string
+
+    constructor(state: MutableState<T>, name: string, mutable: boolean = true) {
+        this.state = state
+        this.mutable = mutable
+        this.name = name
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): T {
+        return this.state.value
+    }
+
+    set(value: T): void {
+        if (this.mutable) this.state.value = value
+    }
+
+    get disposed(): boolean {
+        return this.state.disposed
+    }
+
+    dispose(): void {
+        this.state.dispose()
+    }
+}
+
+class StorageMap {
+    private static _shared?: StorageMap
+    readonly manager = GlobalStateManager.instance
+    readonly map = new Map<string, EntryObject>()
+
+    static get shared(): StorageMap {
+        let shared = StorageMap._shared
+        if (shared?.manager === GlobalStateManager.instance) return shared as StorageMap
+        StorageMap._shared = shared = new StorageMap() // recreate shared storage if state manager is changed
+        return shared
+    }
+
+    constructor(initializer?: IterableIterator<[string, Object]>) {
+        if (initializer) {
+            for (const entry of initializer) {
+                this.create<Object>(entry[0], entry[1])
+            }
+        }
+    }
+
+    keys(): IterableIterator<string> {
+        return this.map.keys()
+    }
+
+    get size(): number {
+        return this.map.size
+    }
+
+    has(key: string): boolean {
+        return this.map.has(key)
+    }
+
+    entry<T>(key: string): StorageEntry<T> | undefined {
+        const entry = this.map.get(key)
+        return entry ? entry as StorageEntry<T> : undefined
+    }
+
+    entryOrCreate<T>(key: string, value: T): StorageEntry<T> {
+        const entry = this.entry<T>(key)
+        if (entry === undefined) return this.create(key, value)
+        if (entry.disposed) return this.create(key, entry.get())
+        return entry
+    }
+
+    get<T>(key: string): T | undefined {
+        const entry = this.entry<T>(key)
+        return entry && entry.state.disposed == false
+            ? entry.get()
+            : undefined
+    }
+
+    set<T>(key: string, value: T, create: boolean = true, mutable: boolean = true): boolean {
+        const entry = this.entry<T>(key)
+        if (entry && entry.disposed == false) {
+            entry.set(value)
+            return true
+        }
+        if (create) {
+            this.create(key, value, mutable)
+            return true
+        }
+        return false
+    }
+
+    link<T>(key: string): SubscribedAbstractProperty<T> | undefined {
+        const entry = this.entry<T>(key)
+        return entry ? new StorageLink<T>(this, entry) : undefined
+    }
+
+    setAndLink<T>(key: string, value: T): SubscribedAbstractProperty<T> {
+        return new StorageLink<T>(this, this.entryOrCreate(key, value))
+    }
+
+    prop<T>(key: string): SubscribedAbstractProperty<T> | undefined {
+        const entry = this.entry<T>(key)
+        return entry ? new StorageProp<T>(this, key, entry.get()) : undefined
+    }
+
+    setAndProp<T>(key: string, value: T): SubscribedAbstractProperty<T> {
+        return new StorageProp<T>(this, key, value)
+    }
+
+    delete(key: string): boolean {
+        const entry = this.map.get(key)
+        if (!entry) return false
+        entry.dispose()
+        return this.map.delete(key)
+    }
+
+    clear(): boolean {
+        if (this.map.size == 0) return false
+        for (const entry of this.map.values()) {
+            entry.dispose()
+        }
+        this.map.clear()
+        return true
+    }
+
+    private create<T>(key: string, value: T, mutable: boolean = true): StorageEntry<T> {
+        const entry = new StorageEntry<T>(this.manager.mutableState(value, true), key, mutable)
+        this.map.set(key, entry)
+        return entry
+    }
+}
+
+/**
+ * This is a @Link implementation for backward compatibility.
+ */
+class StorageLink<T> extends SubscribedAbstractProperty<T> {
+    private readonly map: StorageMap
+    private entry: StorageEntry<T>
+
+    constructor(map: StorageMap, entry: StorageEntry<T>) {
+        super()
+        this.map = map
+        this.entry = entry
+    }
+
+    info(): string {
+        return this.entry.info()
+    }
+
+    get(): T {
+        if (this.entry.disposed) {
+            this.entry = this.map.entryOrCreate(this.info(), this.entry.get())
+        }
+        return this.entry.get()
+    }
+
+    set(value: T): void {
+        if (this.entry.disposed) {
+            this.entry = this.map.entryOrCreate(this.info(), value)
+        } else {
+            this.entry.set(value)
+        }
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+    }
+}
+
+/**
+ * This is a @Prop implementation for backward compatibility.
+ */
+class StorageProp<T> extends SubscribedAbstractProperty<T> {
+    private readonly map: StorageMap
+    private readonly name: string
+    private readonly state: MutableState<T>
+
+    constructor(map: StorageMap, name: string, value: T) {
+        super()
+        this.map = map
+        this.name = name
+        this.state = map.manager.mutableState(value, true)
+    }
+
+    info(): string {
+        return this.name
+    }
+
+    get(): T {
+        let value = this.state.value
+        if (!this.state.disposed) {
+            const entry = this.map.entryOrCreate<T>(this.name, value)
+            if (entry.state.modified) {
+                value = entry.state.value
+                if (this.map.manager.frozen) {
+                    this.map.manager.scheduleCallback(() => { this.set(value) })
+                } else {
+                    this.state.value = value
+                }
+            }
+        }
+        return value
+    }
+
+    set(value: T): void {
+        this.state.value = value
+    }
+
+    subscribe(listener: () => void): void {
+    }
+
+    unsubscribe(listener: () => void): void {
+    }
+
+    aboutToBeDeleted(): void {
+        this.state.dispose()
+    }
+}
diff --git a/arkoala-arkts/arkui-common/ets/index.ts b/arkoala-arkts/arkui-common/ets/index.ts
new file mode 100644
index 0000000000..b7db7562b6
--- /dev/null
+++ b/arkoala-arkts/arkui-common/ets/index.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from "./Storage"
+export * from "./ArkState"
diff --git a/arkoala-arkts/arkui/sdk/component/calendar.ets b/arkoala-arkts/arkui/sdk/component/calendar.ets
new file mode 100644
index 0000000000..d5cd749b22
--- /dev/null
+++ b/arkoala-arkts/arkui/sdk/component/calendar.ets
@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+// WARNING! THIS FILE IS AUTO-GENERATED, DO NOT MAKE CHANGES, THEY WILL BE LOST ON NEXT GENERATION!
+
+import { int32, int64, float32 } from "@koalaui/common"
+import { KInt, KPointer, KBoolean, NativeBuffer, KStringPtr } from "@koalaui/interop"
+import { memo, memo_stable } from "@koalaui/runtime/annotations"
+import { ComponentBuilder } from "@koalaui/builderLambda"
+import { ResourceColor } from "./units"
+import { Color, Axis } from "./enums"
+import { Resource } from "./../generated/resource"
+import { UICommonBase, AttributeModifier, AttributeUpdater } from "./../handwritten"
+export declare interface CalendarDay {
+    index: number;
+    lunarMonth: string;
+    lunarDay: string;
+    dayMark: string;
+    dayMarkValue: string;
+    year: number;
+    month: number;
+    day: number;
+    isFirstOfLunar: boolean;
+    hasSchedule: boolean;
+    markLunarDay: boolean;
+}
+export declare interface MonthData {
+    year: number;
+    month: number;
+    data: Array<CalendarDay>;
+}
+export declare interface CurrentDayStyle {
+    dayColor?: ResourceColor;
+    lunarColor?: ResourceColor;
+    markLunarColor?: ResourceColor;
+    dayFontSize?: number;
+    lunarDayFontSize?: number;
+    dayHeight?: number;
+    dayWidth?: number;
+    gregorianCalendarHeight?: number;
+    dayYAxisOffset?: number;
+    lunarDayYAxisOffset?: number;
+    underscoreXAxisOffset?: number;
+    underscoreYAxisOffset?: number;
+    scheduleMarkerXAxisOffset?: number;
+    scheduleMarkerYAxisOffset?: number;
+    colSpace?: number;
+    dailyFiveRowSpace?: number;
+    dailySixRowSpace?: number;
+    lunarHeight?: number;
+    underscoreWidth?: number;
+    underscoreLength?: number;
+    scheduleMarkerRadius?: number;
+    boundaryRowOffset?: number;
+    boundaryColOffset?: number;
+}
+export declare interface NonCurrentDayStyle {
+    nonCurrentMonthDayColor?: ResourceColor;
+    nonCurrentMonthLunarColor?: ResourceColor;
+    nonCurrentMonthWorkDayMarkColor?: ResourceColor;
+    nonCurrentMonthOffDayMarkColor?: ResourceColor;
+}
+export declare interface TodayStyle {
+    focusedDayColor?: ResourceColor;
+    focusedLunarColor?: ResourceColor;
+    focusedAreaBackgroundColor?: ResourceColor;
+    focusedAreaRadius?: number;
+}
+export declare interface WeekStyle {
+    weekColor?: ResourceColor;
+    weekendDayColor?: ResourceColor;
+    weekendLunarColor?: ResourceColor;
+    weekFontSize?: number;
+    weekHeight?: number;
+    weekWidth?: number;
+    weekAndDayRowSpace?: number;
+}
+export declare interface WorkStateStyle {
+    workDayMarkColor?: ResourceColor;
+    offDayMarkColor?: ResourceColor;
+    workDayMarkSize?: number;
+    offDayMarkSize?: number;
+    workStateWidth?: number;
+    workStateHorizontalMovingDistance?: number;
+    workStateVerticalMovingDistance?: number;
+}
+export declare interface CalendarSelectedDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare interface CalendarRequestedData {
+    year: number;
+    month: number;
+    currentYear: number;
+    currentMonth: number;
+    monthState: number;
+}
+export declare interface DateOptions {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare class CalendarController {
+    constructor()
+    backToToday(): void
+    goTo(date: CalendarSelectedDate): void
+}
+export declare interface CalendarRequestedMonths {
+    date: CalendarSelectedDate;
+    currentData: MonthData;
+    preData: MonthData;
+    nextData: MonthData;
+    controller?: CalendarController;
+}
+export interface CalendarAttribute {
+    showLunar(value: boolean | undefined): this {
+        throw new Error("Unimplemented method showLunar")
+    }
+    showHoliday(value: boolean | undefined): this {
+        throw new Error("Unimplemented method showHoliday")
+    }
+    needSlide(value: boolean | undefined): this {
+        throw new Error("Unimplemented method needSlide")
+    }
+    startOfWeek(value: number | undefined): this {
+        throw new Error("Unimplemented method startOfWeek")
+    }
+    offDays(value: number | undefined): this {
+        throw new Error("Unimplemented method offDays")
+    }
+    direction(value: Axis | undefined): this {
+        throw new Error("Unimplemented method direction")
+    }
+    currentDayStyle(value: CurrentDayStyle | undefined): this {
+        throw new Error("Unimplemented method currentDayStyle")
+    }
+    nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        throw new Error("Unimplemented method nonCurrentDayStyle")
+    }
+    todayStyle(value: TodayStyle | undefined): this {
+        throw new Error("Unimplemented method todayStyle")
+    }
+    weekStyle(value: WeekStyle | undefined): this {
+        throw new Error("Unimplemented method weekStyle")
+    }
+    workStateStyle(value: WorkStateStyle | undefined): this {
+        throw new Error("Unimplemented method workStateStyle")
+    }
+    onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        throw new Error("Unimplemented method onSelectChange")
+    }
+    onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        throw new Error("Unimplemented method onRequestData")
+    }
+    attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        throw new Error("Unimplemented method attributeModifier")
+    }
+}
+export class ArkCalendarStyle implements CalendarAttribute {
+    showLunar_value?: boolean | undefined
+    showHoliday_value?: boolean | undefined
+    needSlide_value?: boolean | undefined
+    startOfWeek_value?: number | undefined
+    offDays_value?: number | undefined
+    direction_value?: Axis | undefined
+    currentDayStyle_value?: CurrentDayStyle | undefined
+    nonCurrentDayStyle_value?: NonCurrentDayStyle | undefined
+    todayStyle_value?: TodayStyle | undefined
+    weekStyle_value?: WeekStyle | undefined
+    workStateStyle_value?: WorkStateStyle | undefined
+    onSelectChange_value?: ((event: CalendarSelectedDate) => void) | undefined
+    onRequestData_value?: ((event: CalendarRequestedData) => void) | undefined
+    public showLunar(value: boolean | undefined): this {
+        return this
+    }
+    public showHoliday(value: boolean | undefined): this {
+        return this
+    }
+    public needSlide(value: boolean | undefined): this {
+        return this
+    }
+    public startOfWeek(value: number | undefined): this {
+        return this
+    }
+    public offDays(value: number | undefined): this {
+        return this
+    }
+    public direction(value: Axis | undefined): this {
+        return this
+    }
+    public currentDayStyle(value: CurrentDayStyle | undefined): this {
+        return this
+    }
+    public nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        return this
+    }
+    public todayStyle(value: TodayStyle | undefined): this {
+        return this
+    }
+    public weekStyle(value: WeekStyle | undefined): this {
+        return this
+    }
+    public workStateStyle(value: WorkStateStyle | undefined): this {
+        return this
+    }
+    public onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        return this
+    }
+    public onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        return this
+    }
+    public attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        throw new Error("Not implemented")
+    }
+    public apply(target: CalendarAttribute): void {
+        if (this.showLunar_value !== undefined)
+            target.showLunar(this.showLunar_value!)
+        if (this.showHoliday_value !== undefined)
+            target.showHoliday(this.showHoliday_value!)
+        if (this.needSlide_value !== undefined)
+            target.needSlide(this.needSlide_value!)
+        if (this.startOfWeek_value !== undefined)
+            target.startOfWeek(this.startOfWeek_value!)
+        if (this.offDays_value !== undefined)
+            target.offDays(this.offDays_value!)
+        if (this.direction_value !== undefined)
+            target.direction(this.direction_value!)
+        if (this.currentDayStyle_value !== undefined)
+            target.currentDayStyle(this.currentDayStyle_value!)
+        if (this.nonCurrentDayStyle_value !== undefined)
+            target.nonCurrentDayStyle(this.nonCurrentDayStyle_value!)
+        if (this.todayStyle_value !== undefined)
+            target.todayStyle(this.todayStyle_value!)
+        if (this.weekStyle_value !== undefined)
+            target.weekStyle(this.weekStyle_value!)
+        if (this.workStateStyle_value !== undefined)
+            target.workStateStyle(this.workStateStyle_value!)
+        if (this.onSelectChange_value !== undefined)
+            target.onSelectChange(this.onSelectChange_value!)
+        if (this.onRequestData_value !== undefined)
+            target.onRequestData(this.onRequestData_value!)
+    }
+}
+
+@memo
+@ComponentBuilder
+export function Calendar(
+    value: CalendarRequestedMonths,
+    @memo
+    content_?: () => void,
+): CalendarAttribute { throw new Error("")}
diff --git a/arkoala-arkts/arkui/sdk/component/extendableComponent.ets b/arkoala-arkts/arkui/sdk/component/extendableComponent.ets
index 93f53346ea..36336c77ff 100644
--- a/arkoala-arkts/arkui/sdk/component/extendableComponent.ets
+++ b/arkoala-arkts/arkui/sdk/component/extendableComponent.ets
@@ -27,7 +27,7 @@ export declare interface LifeCycle {
     onDidBuild(): void
     build(): void
 }
-export declare abstract class ExtendableComponent implements LifeCycle {
+export declare class ExtendableComponent implements LifeCycle {
     constructor()
     getUIContext(): UIContext
     getUniqueId(): int32
diff --git a/arkoala-arkts/arkui/sdk/generated/index.ets b/arkoala-arkts/arkui/sdk/generated/index.ets
index 9ce785cc88..dc4f2ac46d 100644
--- a/arkoala-arkts/arkui/sdk/generated/index.ets
+++ b/arkoala-arkts/arkui/sdk/generated/index.ets
@@ -24,6 +24,7 @@ export * from "./../component/badge"
 export * from "./../component/blank"
 export * from "./../component/builder"
 export * from "./../component/button"
+export * from "./../component/calendar"
 export * from "./../component/calendarPicker"
 export * from "./../component/canvas"
 export * from "./../component/checkbox"
diff --git a/arkoala-arkts/arkui/sdk/generated/ohos.app.ability.common.ets b/arkoala-arkts/arkui/sdk/generated/ohos.app.ability.common.ets
index be10d1576e..be5c9b4124 100644
--- a/arkoala-arkts/arkui/sdk/generated/ohos.app.ability.common.ets
+++ b/arkoala-arkts/arkui/sdk/generated/ohos.app.ability.common.ets
@@ -35,6 +35,6 @@ export declare namespace common {
         cloudFileDir: string;
         createBundleContext(bundleName: string): common.Context
         createModuleContext(moduleName_bundleName: string, moduleName: string): common.Context
-        getGroupDir(dataGroupID: string, callback_: Context_getGroupDir_Callback): undefined | Promise<string>
+        getGroupDir(dataGroupID: string, callback_: Context_getGroupDir_Callback): void | Promise<string>
     }
 }
diff --git a/arkoala-arkts/arkui/src/component/calendar.ets b/arkoala-arkts/arkui/src/component/calendar.ets
new file mode 100644
index 0000000000..9cf49e0286
--- /dev/null
+++ b/arkoala-arkts/arkui/src/component/calendar.ets
@@ -0,0 +1,2228 @@
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+// WARNING! THIS FILE IS AUTO-GENERATED, DO NOT MAKE CHANGES, THEY WILL BE LOST ON NEXT GENERATION!
+
+import { SerializerBase, DeserializerBase, Finalizable, runtimeType, RuntimeType, registerCallback, wrapCallback, toPeerPtr, KPointer, MaterializedBase, NativeBuffer, nullptr, KInt, KBoolean, KStringPtr, CallbackResource, InteropNativeModule, Tags, KSerializerBuffer, KUint8ArrayPtr } from "@koalaui/interop"
+import { TypeChecker, ArkUIGeneratedNativeModule } from "#components"
+import { unsafeCast, int32, int64, float32 } from "@koalaui/common"
+import { CallbackKind } from "./../generated/peers/CallbackKind"
+import { CallbackTransformer } from "./../CallbackTransformer"
+import { ComponentBase } from "./../ComponentBase"
+import { PeerNode } from "./../PeerNode"
+import { Axis, Color } from "./enums"
+import { memo, memo_stable } from "@koalaui/runtime/annotations"
+import { ComponentBuilder } from "@koalaui/builderLambda"
+import { ResourceColor } from "./units"
+import { Resource, Resource_serializer } from "./../generated/resource"
+import { UICommonBase, AttributeModifier, AttributeUpdater } from "./../handwritten"
+import { NodeAttach, remember } from "@koalaui/runtime"
+export class CalendarControllerInternal {
+    public static fromPtr(ptr: KPointer): CalendarController {
+        return new CalendarController(ptr)
+    }
+}
+export class CalendarController implements MaterializedBase {
+    peer?: Finalizable | undefined = undefined
+    public getPeer(): Finalizable | undefined {
+        return this.peer
+    }
+    constructor(peerPtr: KPointer) {
+        this.peer = new Finalizable(peerPtr, CalendarController.getFinalizer())
+    }
+    constructor() {
+        this(CalendarController.construct())
+    }
+    static construct(): KPointer {
+        const retval  = ArkUIGeneratedNativeModule._CalendarController_construct()
+        return retval
+    }
+    static getFinalizer(): KPointer {
+        return ArkUIGeneratedNativeModule._CalendarController_getFinalizer()
+    }
+    public backToToday(): void {
+        this.backToToday_serialize()
+        return
+    }
+    public goTo(date: CalendarSelectedDate): void {
+        const date_casted = date as (CalendarSelectedDate)
+        this.goTo_serialize(date_casted)
+        return
+    }
+    private backToToday_serialize(): void {
+        ArkUIGeneratedNativeModule._CalendarController_backToToday(this.peer!.ptr)
+    }
+    private goTo_serialize(date: CalendarSelectedDate): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        CalendarSelectedDate_serializer.write(thisSerializer, date)
+        ArkUIGeneratedNativeModule._CalendarController_goTo(this.peer!.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+}
+export class ArkCalendarPeer extends PeerNode {
+    protected constructor(peerPtr: KPointer, id: int32, name: string = "", flags: int32 = 0) {
+        super(peerPtr, id, name, flags)
+    }
+    public static create(component?: ComponentBase, flags: int32 = 0): ArkCalendarPeer {
+        const peerId  = PeerNode.nextId()
+        const _peerPtr  = ArkUIGeneratedNativeModule._Calendar_construct(peerId, flags)
+        const _peer  = new ArkCalendarPeer(_peerPtr, peerId, "Calendar", flags)
+        component?.setPeer(_peer)
+        return _peer
+    }
+    setCalendarOptionsAttribute(value: CalendarRequestedMonths): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        CalendarRequestedMonths_serializer.write(thisSerializer, value)
+        ArkUIGeneratedNativeModule._CalendarInterface_setCalendarOptions(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setShowLunarAttribute(value: boolean | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.writeBoolean(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setShowLunar(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setShowHolidayAttribute(value: boolean | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.writeBoolean(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setShowHoliday(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setNeedSlideAttribute(value: boolean | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.writeBoolean(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setNeedSlide(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setStartOfWeekAttribute(value: number | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.writeNumber(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setStartOfWeek(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setOffDaysAttribute(value: number | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.writeNumber(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setOffDays(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setDirectionAttribute(value: Axis | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = (value as Axis)
+            thisSerializer.writeInt32(TypeChecker.Axis_ToNumeric(value_value))
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setDirection(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setCurrentDayStyleAttribute(value: CurrentDayStyle | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            CurrentDayStyle_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setCurrentDayStyle(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setNonCurrentDayStyleAttribute(value: NonCurrentDayStyle | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            NonCurrentDayStyle_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setNonCurrentDayStyle(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setTodayStyleAttribute(value: TodayStyle | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            TodayStyle_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setTodayStyle(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setWeekStyleAttribute(value: WeekStyle | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            WeekStyle_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setWeekStyle(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setWorkStateStyleAttribute(value: WorkStateStyle | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            WorkStateStyle_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setWorkStateStyle(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setOnSelectChangeAttribute(value: ((event: CalendarSelectedDate) => void) | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.holdAndWriteCallback(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setOnSelectChange(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+    setOnRequestDataAttribute(value: ((event: CalendarRequestedData) => void) | undefined): void {
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            thisSerializer.holdAndWriteCallback(value_value)
+        }
+        ArkUIGeneratedNativeModule._CalendarAttribute_setOnRequestData(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
+    }
+}
+export interface CalendarDay {
+    index: number;
+    lunarMonth: string;
+    lunarDay: string;
+    dayMark: string;
+    dayMarkValue: string;
+    year: number;
+    month: number;
+    day: number;
+    isFirstOfLunar: boolean;
+    hasSchedule: boolean;
+    markLunarDay: boolean;
+}
+export interface MonthData {
+    year: number;
+    month: number;
+    data: Array<CalendarDay>;
+}
+export interface CurrentDayStyle {
+    dayColor?: ResourceColor;
+    lunarColor?: ResourceColor;
+    markLunarColor?: ResourceColor;
+    dayFontSize?: number;
+    lunarDayFontSize?: number;
+    dayHeight?: number;
+    dayWidth?: number;
+    gregorianCalendarHeight?: number;
+    dayYAxisOffset?: number;
+    lunarDayYAxisOffset?: number;
+    underscoreXAxisOffset?: number;
+    underscoreYAxisOffset?: number;
+    scheduleMarkerXAxisOffset?: number;
+    scheduleMarkerYAxisOffset?: number;
+    colSpace?: number;
+    dailyFiveRowSpace?: number;
+    dailySixRowSpace?: number;
+    lunarHeight?: number;
+    underscoreWidth?: number;
+    underscoreLength?: number;
+    scheduleMarkerRadius?: number;
+    boundaryRowOffset?: number;
+    boundaryColOffset?: number;
+}
+export interface NonCurrentDayStyle {
+    nonCurrentMonthDayColor?: ResourceColor;
+    nonCurrentMonthLunarColor?: ResourceColor;
+    nonCurrentMonthWorkDayMarkColor?: ResourceColor;
+    nonCurrentMonthOffDayMarkColor?: ResourceColor;
+}
+export interface TodayStyle {
+    focusedDayColor?: ResourceColor;
+    focusedLunarColor?: ResourceColor;
+    focusedAreaBackgroundColor?: ResourceColor;
+    focusedAreaRadius?: number;
+}
+export interface WeekStyle {
+    weekColor?: ResourceColor;
+    weekendDayColor?: ResourceColor;
+    weekendLunarColor?: ResourceColor;
+    weekFontSize?: number;
+    weekHeight?: number;
+    weekWidth?: number;
+    weekAndDayRowSpace?: number;
+}
+export interface WorkStateStyle {
+    workDayMarkColor?: ResourceColor;
+    offDayMarkColor?: ResourceColor;
+    workDayMarkSize?: number;
+    offDayMarkSize?: number;
+    workStateWidth?: number;
+    workStateHorizontalMovingDistance?: number;
+    workStateVerticalMovingDistance?: number;
+}
+export interface CalendarSelectedDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface CalendarRequestedData {
+    year: number;
+    month: number;
+    currentYear: number;
+    currentMonth: number;
+    monthState: number;
+}
+export interface DateOptions {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface CalendarRequestedMonths {
+    date: CalendarSelectedDate;
+    currentData: MonthData;
+    preData: MonthData;
+    nextData: MonthData;
+    controller?: CalendarController;
+}
+export interface CalendarAttribute {
+    showLunar(value: boolean | undefined): this {
+        throw new Error("Unimplemented method showLunar")
+    }
+    showHoliday(value: boolean | undefined): this {
+        throw new Error("Unimplemented method showHoliday")
+    }
+    needSlide(value: boolean | undefined): this {
+        throw new Error("Unimplemented method needSlide")
+    }
+    startOfWeek(value: number | undefined): this {
+        throw new Error("Unimplemented method startOfWeek")
+    }
+    offDays(value: number | undefined): this {
+        throw new Error("Unimplemented method offDays")
+    }
+    direction(value: Axis | undefined): this {
+        throw new Error("Unimplemented method direction")
+    }
+    currentDayStyle(value: CurrentDayStyle | undefined): this {
+        throw new Error("Unimplemented method currentDayStyle")
+    }
+    nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        throw new Error("Unimplemented method nonCurrentDayStyle")
+    }
+    todayStyle(value: TodayStyle | undefined): this {
+        throw new Error("Unimplemented method todayStyle")
+    }
+    weekStyle(value: WeekStyle | undefined): this {
+        throw new Error("Unimplemented method weekStyle")
+    }
+    workStateStyle(value: WorkStateStyle | undefined): this {
+        throw new Error("Unimplemented method workStateStyle")
+    }
+    onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        throw new Error("Unimplemented method onSelectChange")
+    }
+    onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        throw new Error("Unimplemented method onRequestData")
+    }
+    attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        throw new Error("Unimplemented method attributeModifier")
+    }
+}
+export class ArkCalendarStyle implements CalendarAttribute {
+    showLunar_value?: boolean | undefined
+    showHoliday_value?: boolean | undefined
+    needSlide_value?: boolean | undefined
+    startOfWeek_value?: number | undefined
+    offDays_value?: number | undefined
+    direction_value?: Axis | undefined
+    currentDayStyle_value?: CurrentDayStyle | undefined
+    nonCurrentDayStyle_value?: NonCurrentDayStyle | undefined
+    todayStyle_value?: TodayStyle | undefined
+    weekStyle_value?: WeekStyle | undefined
+    workStateStyle_value?: WorkStateStyle | undefined
+    onSelectChange_value?: ((event: CalendarSelectedDate) => void) | undefined
+    onRequestData_value?: ((event: CalendarRequestedData) => void) | undefined
+    public showLunar(value: boolean | undefined): this {
+        return this
+    }
+    public showHoliday(value: boolean | undefined): this {
+        return this
+    }
+    public needSlide(value: boolean | undefined): this {
+        return this
+    }
+    public startOfWeek(value: number | undefined): this {
+        return this
+    }
+    public offDays(value: number | undefined): this {
+        return this
+    }
+    public direction(value: Axis | undefined): this {
+        return this
+    }
+    public currentDayStyle(value: CurrentDayStyle | undefined): this {
+        return this
+    }
+    public nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        return this
+    }
+    public todayStyle(value: TodayStyle | undefined): this {
+        return this
+    }
+    public weekStyle(value: WeekStyle | undefined): this {
+        return this
+    }
+    public workStateStyle(value: WorkStateStyle | undefined): this {
+        return this
+    }
+    public onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        return this
+    }
+    public onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        return this
+    }
+    public attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        throw new Error("Not implemented")
+    }
+    public apply(target: CalendarAttribute): void {
+        if (this.showLunar_value !== undefined)
+            target.showLunar(this.showLunar_value!)
+        if (this.showHoliday_value !== undefined)
+            target.showHoliday(this.showHoliday_value!)
+        if (this.needSlide_value !== undefined)
+            target.needSlide(this.needSlide_value!)
+        if (this.startOfWeek_value !== undefined)
+            target.startOfWeek(this.startOfWeek_value!)
+        if (this.offDays_value !== undefined)
+            target.offDays(this.offDays_value!)
+        if (this.direction_value !== undefined)
+            target.direction(this.direction_value!)
+        if (this.currentDayStyle_value !== undefined)
+            target.currentDayStyle(this.currentDayStyle_value!)
+        if (this.nonCurrentDayStyle_value !== undefined)
+            target.nonCurrentDayStyle(this.nonCurrentDayStyle_value!)
+        if (this.todayStyle_value !== undefined)
+            target.todayStyle(this.todayStyle_value!)
+        if (this.weekStyle_value !== undefined)
+            target.weekStyle(this.weekStyle_value!)
+        if (this.workStateStyle_value !== undefined)
+            target.workStateStyle(this.workStateStyle_value!)
+        if (this.onSelectChange_value !== undefined)
+            target.onSelectChange(this.onSelectChange_value!)
+        if (this.onRequestData_value !== undefined)
+            target.onRequestData(this.onRequestData_value!)
+    }
+}
+
+export class ArkCalendarComponent extends ComponentBase implements CalendarAttribute {
+    getPeer(): ArkCalendarPeer {
+        return (this.peer as ArkCalendarPeer)
+    }
+    public setCalendarOptions(value: CalendarRequestedMonths): this {
+        if (this.checkPriority("setCalendarOptions")) {
+            const value_casted = value as (CalendarRequestedMonths)
+            this.getPeer()?.setCalendarOptionsAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public showLunar(value: boolean | undefined): this {
+        if (this.checkPriority("showLunar")) {
+            const value_casted = value as (boolean | undefined)
+            this.getPeer()?.setShowLunarAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public showHoliday(value: boolean | undefined): this {
+        if (this.checkPriority("showHoliday")) {
+            const value_casted = value as (boolean | undefined)
+            this.getPeer()?.setShowHolidayAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public needSlide(value: boolean | undefined): this {
+        if (this.checkPriority("needSlide")) {
+            const value_casted = value as (boolean | undefined)
+            this.getPeer()?.setNeedSlideAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public startOfWeek(value: number | undefined): this {
+        if (this.checkPriority("startOfWeek")) {
+            const value_casted = value as (number | undefined)
+            this.getPeer()?.setStartOfWeekAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public offDays(value: number | undefined): this {
+        if (this.checkPriority("offDays")) {
+            const value_casted = value as (number | undefined)
+            this.getPeer()?.setOffDaysAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public direction(value: Axis | undefined): this {
+        if (this.checkPriority("direction")) {
+            const value_casted = value as (Axis | undefined)
+            this.getPeer()?.setDirectionAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public currentDayStyle(value: CurrentDayStyle | undefined): this {
+        if (this.checkPriority("currentDayStyle")) {
+            const value_casted = value as (CurrentDayStyle | undefined)
+            this.getPeer()?.setCurrentDayStyleAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        if (this.checkPriority("nonCurrentDayStyle")) {
+            const value_casted = value as (NonCurrentDayStyle | undefined)
+            this.getPeer()?.setNonCurrentDayStyleAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public todayStyle(value: TodayStyle | undefined): this {
+        if (this.checkPriority("todayStyle")) {
+            const value_casted = value as (TodayStyle | undefined)
+            this.getPeer()?.setTodayStyleAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public weekStyle(value: WeekStyle | undefined): this {
+        if (this.checkPriority("weekStyle")) {
+            const value_casted = value as (WeekStyle | undefined)
+            this.getPeer()?.setWeekStyleAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public workStateStyle(value: WorkStateStyle | undefined): this {
+        if (this.checkPriority("workStateStyle")) {
+            const value_casted = value as (WorkStateStyle | undefined)
+            this.getPeer()?.setWorkStateStyleAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        if (this.checkPriority("onSelectChange")) {
+            const value_casted = value as (((event: CalendarSelectedDate) => void) | undefined)
+            this.getPeer()?.setOnSelectChangeAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    public onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        if (this.checkPriority("onRequestData")) {
+            const value_casted = value as (((event: CalendarRequestedData) => void) | undefined)
+            this.getPeer()?.setOnRequestDataAttribute(value_casted)
+            return this
+        }
+        return this
+    }
+    _modifier?: AttributeModifier<CalendarAttribute> | undefined
+    public attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        this._modifier = value
+        return this
+    }
+    public applyAttributesFinish(): void {
+        // we call this function outside of class, so need to make it public
+        super.applyAttributesFinish()
+    }
+}
+export function withCalendarStyle(receiver: CalendarAttribute, modifier: AttributeModifier<CalendarAttribute> | undefined): void {
+    if (modifier !== undefined)
+    {
+        let style  = new ArkCalendarStyle()
+        if (modifier!.isUpdater())
+            (modifier! as AttributeUpdater<CalendarAttribute>).initializeModifier(style)
+        else
+            (modifier! as AttributeModifier<CalendarAttribute>).applyNormalAttribute(style)
+        style.apply(receiver)
+    }
+}
+// @memo
+// @BuilderLambda("Calendar")
+// export function Calendar(
+//     value: CalendarRequestedMonths,
+//     @memo
+//     content_?: () => void,
+// ): CalendarAttribute {
+//     throw new Error("Not implemented")
+// }
+
+@memo
+export function Calendar(
+    @memo
+    style: ((attributes: CalendarAttribute) => void) | undefined,
+    value: CalendarRequestedMonths,
+    @memo
+    content_?: () => void,
+): void {
+    const receiver = remember<ArkCalendarComponent>((): ArkCalendarComponent => {
+        return new ArkCalendarComponent()
+    })
+    NodeAttach<ArkCalendarPeer>((): ArkCalendarPeer => ArkCalendarPeer.create(receiver), (_: ArkCalendarPeer): void => {
+        receiver.setCalendarOptions(value)
+        style?.(receiver)
+        withCalendarStyle(receiver, receiver._modifier)
+        content_?.()
+        receiver.applyAttributesFinish()
+    })
+}
+
+export class ArkCalendarSet implements CalendarAttribute {
+    _instanceId: number = -1;
+    setInstanceId(instanceId: number): void {
+        this._instanceId = instanceId
+    }
+    _showLunar_flag?: boolean
+    _showLunar0_value?: boolean | undefined
+    _showHoliday_flag?: boolean
+    _showHoliday0_value?: boolean | undefined
+    _needSlide_flag?: boolean
+    _needSlide0_value?: boolean | undefined
+    _startOfWeek_flag?: boolean
+    _startOfWeek0_value?: number | undefined
+    _offDays_flag?: boolean
+    _offDays0_value?: number | undefined
+    _direction_flag?: boolean
+    _direction0_value?: Axis | undefined
+    _currentDayStyle_flag?: boolean
+    _currentDayStyle0_value?: CurrentDayStyle | undefined
+    _nonCurrentDayStyle_flag?: boolean
+    _nonCurrentDayStyle0_value?: NonCurrentDayStyle | undefined
+    _todayStyle_flag?: boolean
+    _todayStyle0_value?: TodayStyle | undefined
+    _weekStyle_flag?: boolean
+    _weekStyle0_value?: WeekStyle | undefined
+    _workStateStyle_flag?: boolean
+    _workStateStyle0_value?: WorkStateStyle | undefined
+    _onSelectChange_flag?: boolean
+    _onSelectChange0_value?: ((event: CalendarSelectedDate) => void) | undefined
+    _onRequestData_flag?: boolean
+    _onRequestData0_value?: ((event: CalendarRequestedData) => void) | undefined
+    applyModifierPatch(component: CalendarAttribute): void {
+        if (this._showLunar_flag)
+            component.showLunar((this._showLunar0_value as boolean | undefined))
+        if (this._showHoliday_flag)
+            component.showHoliday((this._showHoliday0_value as boolean | undefined))
+        if (this._needSlide_flag)
+            component.needSlide((this._needSlide0_value as boolean | undefined))
+        if (this._startOfWeek_flag)
+            component.startOfWeek((this._startOfWeek0_value as number | undefined))
+        if (this._offDays_flag)
+            component.offDays((this._offDays0_value as number | undefined))
+        if (this._direction_flag)
+            component.direction((this._direction0_value as Axis | undefined))
+        if (this._currentDayStyle_flag)
+            component.currentDayStyle((this._currentDayStyle0_value as CurrentDayStyle | undefined))
+        if (this._nonCurrentDayStyle_flag)
+            component.nonCurrentDayStyle((this._nonCurrentDayStyle0_value as NonCurrentDayStyle | undefined))
+        if (this._todayStyle_flag)
+            component.todayStyle((this._todayStyle0_value as TodayStyle | undefined))
+        if (this._weekStyle_flag)
+            component.weekStyle((this._weekStyle0_value as WeekStyle | undefined))
+        if (this._workStateStyle_flag)
+            component.workStateStyle((this._workStateStyle0_value as WorkStateStyle | undefined))
+        if (this._onSelectChange_flag)
+            component.onSelectChange((this._onSelectChange0_value as ((event: CalendarSelectedDate) => void) | undefined))
+        if (this._onRequestData_flag)
+            component.onRequestData((this._onRequestData0_value as ((event: CalendarRequestedData) => void) | undefined))
+    }
+    public showLunar(value: boolean | undefined): this {
+        this._showLunar_flag = true
+        this._showLunar0_value = value
+        return this
+    }
+    public showHoliday(value: boolean | undefined): this {
+        this._showHoliday_flag = true
+        this._showHoliday0_value = value
+        return this
+    }
+    public needSlide(value: boolean | undefined): this {
+        this._needSlide_flag = true
+        this._needSlide0_value = value
+        return this
+    }
+    public startOfWeek(value: number | undefined): this {
+        this._startOfWeek_flag = true
+        this._startOfWeek0_value = value
+        return this
+    }
+    public offDays(value: number | undefined): this {
+        this._offDays_flag = true
+        this._offDays0_value = value
+        return this
+    }
+    public direction(value: Axis | undefined): this {
+        this._direction_flag = true
+        this._direction0_value = value
+        return this
+    }
+    public currentDayStyle(value: CurrentDayStyle | undefined): this {
+        this._currentDayStyle_flag = true
+        this._currentDayStyle0_value = value
+        return this
+    }
+    public nonCurrentDayStyle(value: NonCurrentDayStyle | undefined): this {
+        this._nonCurrentDayStyle_flag = true
+        this._nonCurrentDayStyle0_value = value
+        return this
+    }
+    public todayStyle(value: TodayStyle | undefined): this {
+        this._todayStyle_flag = true
+        this._todayStyle0_value = value
+        return this
+    }
+    public weekStyle(value: WeekStyle | undefined): this {
+        this._weekStyle_flag = true
+        this._weekStyle0_value = value
+        return this
+    }
+    public workStateStyle(value: WorkStateStyle | undefined): this {
+        this._workStateStyle_flag = true
+        this._workStateStyle0_value = value
+        return this
+    }
+    public onSelectChange(value: ((event: CalendarSelectedDate) => void) | undefined): this {
+        this._onSelectChange_flag = true
+        this._onSelectChange0_value = value
+        return this
+    }
+    public onRequestData(value: ((event: CalendarRequestedData) => void) | undefined): this {
+        this._onRequestData_flag = true
+        this._onRequestData0_value = value
+        return this
+    }
+    public attributeModifier(value: AttributeModifier<CalendarAttribute> | undefined): this {
+        throw new Error("Not implemented")
+    }
+}
+export class CalendarController_serializer {
+    public static write(buffer: SerializerBase, value: CalendarController): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): CalendarController {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return CalendarControllerInternal.fromPtr(ptr)
+    }
+}
+export class CalendarDay_serializer {
+    public static write(buffer: SerializerBase, value: CalendarDay): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_index  = value.index
+        valueSerializer.writeNumber(value_index)
+        const value_lunarMonth  = value.lunarMonth
+        valueSerializer.writeString(value_lunarMonth)
+        const value_lunarDay  = value.lunarDay
+        valueSerializer.writeString(value_lunarDay)
+        const value_dayMark  = value.dayMark
+        valueSerializer.writeString(value_dayMark)
+        const value_dayMarkValue  = value.dayMarkValue
+        valueSerializer.writeString(value_dayMarkValue)
+        const value_year  = value.year
+        valueSerializer.writeNumber(value_year)
+        const value_month  = value.month
+        valueSerializer.writeNumber(value_month)
+        const value_day  = value.day
+        valueSerializer.writeNumber(value_day)
+        const value_isFirstOfLunar  = value.isFirstOfLunar
+        valueSerializer.writeBoolean(value_isFirstOfLunar)
+        const value_hasSchedule  = value.hasSchedule
+        valueSerializer.writeBoolean(value_hasSchedule)
+        const value_markLunarDay  = value.markLunarDay
+        valueSerializer.writeBoolean(value_markLunarDay)
+    }
+    public static read(buffer: DeserializerBase): CalendarDay {
+        let valueDeserializer : DeserializerBase = buffer
+        const index_result : number = (valueDeserializer.readNumber() as number)
+        const lunarMonth_result : string = (valueDeserializer.readString() as string)
+        const lunarDay_result : string = (valueDeserializer.readString() as string)
+        const dayMark_result : string = (valueDeserializer.readString() as string)
+        const dayMarkValue_result : string = (valueDeserializer.readString() as string)
+        const year_result : number = (valueDeserializer.readNumber() as number)
+        const month_result : number = (valueDeserializer.readNumber() as number)
+        const day_result : number = (valueDeserializer.readNumber() as number)
+        const isFirstOfLunar_result : boolean = valueDeserializer.readBoolean()
+        const hasSchedule_result : boolean = valueDeserializer.readBoolean()
+        const markLunarDay_result : boolean = valueDeserializer.readBoolean()
+        let value : CalendarDay = ({index: index_result, lunarMonth: lunarMonth_result, lunarDay: lunarDay_result, dayMark: dayMark_result, dayMarkValue: dayMarkValue_result, year: year_result, month: month_result, day: day_result, isFirstOfLunar: isFirstOfLunar_result, hasSchedule: hasSchedule_result, markLunarDay: markLunarDay_result} as CalendarDay)
+        return value
+    }
+}
+export class CalendarRequestedData_serializer {
+    public static write(buffer: SerializerBase, value: CalendarRequestedData): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_year  = value.year
+        valueSerializer.writeNumber(value_year)
+        const value_month  = value.month
+        valueSerializer.writeNumber(value_month)
+        const value_currentYear  = value.currentYear
+        valueSerializer.writeNumber(value_currentYear)
+        const value_currentMonth  = value.currentMonth
+        valueSerializer.writeNumber(value_currentMonth)
+        const value_monthState  = value.monthState
+        valueSerializer.writeNumber(value_monthState)
+    }
+    public static read(buffer: DeserializerBase): CalendarRequestedData {
+        let valueDeserializer : DeserializerBase = buffer
+        const year_result : number = (valueDeserializer.readNumber() as number)
+        const month_result : number = (valueDeserializer.readNumber() as number)
+        const currentYear_result : number = (valueDeserializer.readNumber() as number)
+        const currentMonth_result : number = (valueDeserializer.readNumber() as number)
+        const monthState_result : number = (valueDeserializer.readNumber() as number)
+        let value : CalendarRequestedData = ({year: year_result, month: month_result, currentYear: currentYear_result, currentMonth: currentMonth_result, monthState: monthState_result} as CalendarRequestedData)
+        return value
+    }
+}
+export class CalendarSelectedDate_serializer {
+    public static write(buffer: SerializerBase, value: CalendarSelectedDate): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_year  = value.year
+        valueSerializer.writeNumber(value_year)
+        const value_month  = value.month
+        valueSerializer.writeNumber(value_month)
+        const value_day  = value.day
+        valueSerializer.writeNumber(value_day)
+    }
+    public static read(buffer: DeserializerBase): CalendarSelectedDate {
+        let valueDeserializer : DeserializerBase = buffer
+        const year_result : number = (valueDeserializer.readNumber() as number)
+        const month_result : number = (valueDeserializer.readNumber() as number)
+        const day_result : number = (valueDeserializer.readNumber() as number)
+        let value : CalendarSelectedDate = ({year: year_result, month: month_result, day: day_result} as CalendarSelectedDate)
+        return value
+    }
+}
+export class MonthData_serializer {
+    public static write(buffer: SerializerBase, value: MonthData): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_year  = value.year
+        valueSerializer.writeNumber(value_year)
+        const value_month  = value.month
+        valueSerializer.writeNumber(value_month)
+        const value_data  = value.data
+        valueSerializer.writeInt32((value_data.length).toInt())
+        for (let value_data_counter_i = 0; value_data_counter_i < value_data.length; value_data_counter_i++) {
+            const value_data_element : CalendarDay = value_data[value_data_counter_i]
+            CalendarDay_serializer.write(valueSerializer, value_data_element)
+        }
+    }
+    public static read(buffer: DeserializerBase): MonthData {
+        let valueDeserializer : DeserializerBase = buffer
+        const year_result : number = (valueDeserializer.readNumber() as number)
+        const month_result : number = (valueDeserializer.readNumber() as number)
+        const data_buf_length : int32 = valueDeserializer.readInt32()
+        let data_buf : Array<CalendarDay> = new Array<CalendarDay>(data_buf_length)
+        for (let data_buf_i = 0; data_buf_i < data_buf_length; data_buf_i++) {
+            data_buf[data_buf_i] = CalendarDay_serializer.read(valueDeserializer)
+        }
+        const data_result : Array<CalendarDay> = data_buf
+        let value : MonthData = ({year: year_result, month: month_result, data: data_result} as MonthData)
+        return value
+    }
+}
+export class CalendarRequestedMonths_serializer {
+    public static write(buffer: SerializerBase, value: CalendarRequestedMonths): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_date  = value.date
+        CalendarSelectedDate_serializer.write(valueSerializer, value_date)
+        const value_currentData  = value.currentData
+        MonthData_serializer.write(valueSerializer, value_currentData)
+        const value_preData  = value.preData
+        MonthData_serializer.write(valueSerializer, value_preData)
+        const value_nextData  = value.nextData
+        MonthData_serializer.write(valueSerializer, value_nextData)
+        const value_controller  = value.controller
+        let value_controller_type : int32 = RuntimeType.UNDEFINED
+        value_controller_type = runtimeType(value_controller)
+        valueSerializer.writeInt8((value_controller_type).toChar())
+        if ((value_controller_type) != (RuntimeType.UNDEFINED)) {
+            const value_controller_value  = value_controller!
+            CalendarController_serializer.write(valueSerializer, value_controller_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): CalendarRequestedMonths {
+        let valueDeserializer : DeserializerBase = buffer
+        const date_result : CalendarSelectedDate = CalendarSelectedDate_serializer.read(valueDeserializer)
+        const currentData_result : MonthData = MonthData_serializer.read(valueDeserializer)
+        const preData_result : MonthData = MonthData_serializer.read(valueDeserializer)
+        const nextData_result : MonthData = MonthData_serializer.read(valueDeserializer)
+        const controller_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let controller_buf : CalendarController | undefined
+        if ((controller_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            controller_buf = (CalendarController_serializer.read(valueDeserializer) as CalendarController)
+        }
+        const controller_result : CalendarController | undefined = controller_buf
+        let value : CalendarRequestedMonths = ({date: date_result, currentData: currentData_result, preData: preData_result, nextData: nextData_result, controller: controller_result} as CalendarRequestedMonths)
+        return value
+    }
+}
+export class CurrentDayStyle_serializer {
+    public static write(buffer: SerializerBase, value: CurrentDayStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_dayColor  = value.dayColor
+        let value_dayColor_type : int32 = RuntimeType.UNDEFINED
+        value_dayColor_type = runtimeType(value_dayColor)
+        valueSerializer.writeInt8((value_dayColor_type).toChar())
+        if ((value_dayColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_dayColor_value  = value_dayColor!
+            let value_dayColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_dayColor_value_type = runtimeType(value_dayColor_value)
+            if (TypeChecker.isColor(value_dayColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_dayColor_value_0  = value_dayColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_dayColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_dayColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_dayColor_value_1  = value_dayColor_value as number
+                valueSerializer.writeNumber(value_dayColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_dayColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_dayColor_value_2  = value_dayColor_value as string
+                valueSerializer.writeString(value_dayColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_dayColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_dayColor_value_3  = value_dayColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_dayColor_value_3)
+            }
+        }
+        const value_lunarColor  = value.lunarColor
+        let value_lunarColor_type : int32 = RuntimeType.UNDEFINED
+        value_lunarColor_type = runtimeType(value_lunarColor)
+        valueSerializer.writeInt8((value_lunarColor_type).toChar())
+        if ((value_lunarColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_lunarColor_value  = value_lunarColor!
+            let value_lunarColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_lunarColor_value_type = runtimeType(value_lunarColor_value)
+            if (TypeChecker.isColor(value_lunarColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_lunarColor_value_0  = value_lunarColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_lunarColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_lunarColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_lunarColor_value_1  = value_lunarColor_value as number
+                valueSerializer.writeNumber(value_lunarColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_lunarColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_lunarColor_value_2  = value_lunarColor_value as string
+                valueSerializer.writeString(value_lunarColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_lunarColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_lunarColor_value_3  = value_lunarColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_lunarColor_value_3)
+            }
+        }
+        const value_markLunarColor  = value.markLunarColor
+        let value_markLunarColor_type : int32 = RuntimeType.UNDEFINED
+        value_markLunarColor_type = runtimeType(value_markLunarColor)
+        valueSerializer.writeInt8((value_markLunarColor_type).toChar())
+        if ((value_markLunarColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_markLunarColor_value  = value_markLunarColor!
+            let value_markLunarColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_markLunarColor_value_type = runtimeType(value_markLunarColor_value)
+            if (TypeChecker.isColor(value_markLunarColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_markLunarColor_value_0  = value_markLunarColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_markLunarColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_markLunarColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_markLunarColor_value_1  = value_markLunarColor_value as number
+                valueSerializer.writeNumber(value_markLunarColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_markLunarColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_markLunarColor_value_2  = value_markLunarColor_value as string
+                valueSerializer.writeString(value_markLunarColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_markLunarColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_markLunarColor_value_3  = value_markLunarColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_markLunarColor_value_3)
+            }
+        }
+        const value_dayFontSize  = value.dayFontSize
+        let value_dayFontSize_type : int32 = RuntimeType.UNDEFINED
+        value_dayFontSize_type = runtimeType(value_dayFontSize)
+        valueSerializer.writeInt8((value_dayFontSize_type).toChar())
+        if ((value_dayFontSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_dayFontSize_value  = value_dayFontSize!
+            valueSerializer.writeNumber(value_dayFontSize_value)
+        }
+        const value_lunarDayFontSize  = value.lunarDayFontSize
+        let value_lunarDayFontSize_type : int32 = RuntimeType.UNDEFINED
+        value_lunarDayFontSize_type = runtimeType(value_lunarDayFontSize)
+        valueSerializer.writeInt8((value_lunarDayFontSize_type).toChar())
+        if ((value_lunarDayFontSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_lunarDayFontSize_value  = value_lunarDayFontSize!
+            valueSerializer.writeNumber(value_lunarDayFontSize_value)
+        }
+        const value_dayHeight  = value.dayHeight
+        let value_dayHeight_type : int32 = RuntimeType.UNDEFINED
+        value_dayHeight_type = runtimeType(value_dayHeight)
+        valueSerializer.writeInt8((value_dayHeight_type).toChar())
+        if ((value_dayHeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_dayHeight_value  = value_dayHeight!
+            valueSerializer.writeNumber(value_dayHeight_value)
+        }
+        const value_dayWidth  = value.dayWidth
+        let value_dayWidth_type : int32 = RuntimeType.UNDEFINED
+        value_dayWidth_type = runtimeType(value_dayWidth)
+        valueSerializer.writeInt8((value_dayWidth_type).toChar())
+        if ((value_dayWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_dayWidth_value  = value_dayWidth!
+            valueSerializer.writeNumber(value_dayWidth_value)
+        }
+        const value_gregorianCalendarHeight  = value.gregorianCalendarHeight
+        let value_gregorianCalendarHeight_type : int32 = RuntimeType.UNDEFINED
+        value_gregorianCalendarHeight_type = runtimeType(value_gregorianCalendarHeight)
+        valueSerializer.writeInt8((value_gregorianCalendarHeight_type).toChar())
+        if ((value_gregorianCalendarHeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_gregorianCalendarHeight_value  = value_gregorianCalendarHeight!
+            valueSerializer.writeNumber(value_gregorianCalendarHeight_value)
+        }
+        const value_dayYAxisOffset  = value.dayYAxisOffset
+        let value_dayYAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_dayYAxisOffset_type = runtimeType(value_dayYAxisOffset)
+        valueSerializer.writeInt8((value_dayYAxisOffset_type).toChar())
+        if ((value_dayYAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_dayYAxisOffset_value  = value_dayYAxisOffset!
+            valueSerializer.writeNumber(value_dayYAxisOffset_value)
+        }
+        const value_lunarDayYAxisOffset  = value.lunarDayYAxisOffset
+        let value_lunarDayYAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_lunarDayYAxisOffset_type = runtimeType(value_lunarDayYAxisOffset)
+        valueSerializer.writeInt8((value_lunarDayYAxisOffset_type).toChar())
+        if ((value_lunarDayYAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_lunarDayYAxisOffset_value  = value_lunarDayYAxisOffset!
+            valueSerializer.writeNumber(value_lunarDayYAxisOffset_value)
+        }
+        const value_underscoreXAxisOffset  = value.underscoreXAxisOffset
+        let value_underscoreXAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_underscoreXAxisOffset_type = runtimeType(value_underscoreXAxisOffset)
+        valueSerializer.writeInt8((value_underscoreXAxisOffset_type).toChar())
+        if ((value_underscoreXAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_underscoreXAxisOffset_value  = value_underscoreXAxisOffset!
+            valueSerializer.writeNumber(value_underscoreXAxisOffset_value)
+        }
+        const value_underscoreYAxisOffset  = value.underscoreYAxisOffset
+        let value_underscoreYAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_underscoreYAxisOffset_type = runtimeType(value_underscoreYAxisOffset)
+        valueSerializer.writeInt8((value_underscoreYAxisOffset_type).toChar())
+        if ((value_underscoreYAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_underscoreYAxisOffset_value  = value_underscoreYAxisOffset!
+            valueSerializer.writeNumber(value_underscoreYAxisOffset_value)
+        }
+        const value_scheduleMarkerXAxisOffset  = value.scheduleMarkerXAxisOffset
+        let value_scheduleMarkerXAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_scheduleMarkerXAxisOffset_type = runtimeType(value_scheduleMarkerXAxisOffset)
+        valueSerializer.writeInt8((value_scheduleMarkerXAxisOffset_type).toChar())
+        if ((value_scheduleMarkerXAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_scheduleMarkerXAxisOffset_value  = value_scheduleMarkerXAxisOffset!
+            valueSerializer.writeNumber(value_scheduleMarkerXAxisOffset_value)
+        }
+        const value_scheduleMarkerYAxisOffset  = value.scheduleMarkerYAxisOffset
+        let value_scheduleMarkerYAxisOffset_type : int32 = RuntimeType.UNDEFINED
+        value_scheduleMarkerYAxisOffset_type = runtimeType(value_scheduleMarkerYAxisOffset)
+        valueSerializer.writeInt8((value_scheduleMarkerYAxisOffset_type).toChar())
+        if ((value_scheduleMarkerYAxisOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_scheduleMarkerYAxisOffset_value  = value_scheduleMarkerYAxisOffset!
+            valueSerializer.writeNumber(value_scheduleMarkerYAxisOffset_value)
+        }
+        const value_colSpace  = value.colSpace
+        let value_colSpace_type : int32 = RuntimeType.UNDEFINED
+        value_colSpace_type = runtimeType(value_colSpace)
+        valueSerializer.writeInt8((value_colSpace_type).toChar())
+        if ((value_colSpace_type) != (RuntimeType.UNDEFINED)) {
+            const value_colSpace_value  = value_colSpace!
+            valueSerializer.writeNumber(value_colSpace_value)
+        }
+        const value_dailyFiveRowSpace  = value.dailyFiveRowSpace
+        let value_dailyFiveRowSpace_type : int32 = RuntimeType.UNDEFINED
+        value_dailyFiveRowSpace_type = runtimeType(value_dailyFiveRowSpace)
+        valueSerializer.writeInt8((value_dailyFiveRowSpace_type).toChar())
+        if ((value_dailyFiveRowSpace_type) != (RuntimeType.UNDEFINED)) {
+            const value_dailyFiveRowSpace_value  = value_dailyFiveRowSpace!
+            valueSerializer.writeNumber(value_dailyFiveRowSpace_value)
+        }
+        const value_dailySixRowSpace  = value.dailySixRowSpace
+        let value_dailySixRowSpace_type : int32 = RuntimeType.UNDEFINED
+        value_dailySixRowSpace_type = runtimeType(value_dailySixRowSpace)
+        valueSerializer.writeInt8((value_dailySixRowSpace_type).toChar())
+        if ((value_dailySixRowSpace_type) != (RuntimeType.UNDEFINED)) {
+            const value_dailySixRowSpace_value  = value_dailySixRowSpace!
+            valueSerializer.writeNumber(value_dailySixRowSpace_value)
+        }
+        const value_lunarHeight  = value.lunarHeight
+        let value_lunarHeight_type : int32 = RuntimeType.UNDEFINED
+        value_lunarHeight_type = runtimeType(value_lunarHeight)
+        valueSerializer.writeInt8((value_lunarHeight_type).toChar())
+        if ((value_lunarHeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_lunarHeight_value  = value_lunarHeight!
+            valueSerializer.writeNumber(value_lunarHeight_value)
+        }
+        const value_underscoreWidth  = value.underscoreWidth
+        let value_underscoreWidth_type : int32 = RuntimeType.UNDEFINED
+        value_underscoreWidth_type = runtimeType(value_underscoreWidth)
+        valueSerializer.writeInt8((value_underscoreWidth_type).toChar())
+        if ((value_underscoreWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_underscoreWidth_value  = value_underscoreWidth!
+            valueSerializer.writeNumber(value_underscoreWidth_value)
+        }
+        const value_underscoreLength  = value.underscoreLength
+        let value_underscoreLength_type : int32 = RuntimeType.UNDEFINED
+        value_underscoreLength_type = runtimeType(value_underscoreLength)
+        valueSerializer.writeInt8((value_underscoreLength_type).toChar())
+        if ((value_underscoreLength_type) != (RuntimeType.UNDEFINED)) {
+            const value_underscoreLength_value  = value_underscoreLength!
+            valueSerializer.writeNumber(value_underscoreLength_value)
+        }
+        const value_scheduleMarkerRadius  = value.scheduleMarkerRadius
+        let value_scheduleMarkerRadius_type : int32 = RuntimeType.UNDEFINED
+        value_scheduleMarkerRadius_type = runtimeType(value_scheduleMarkerRadius)
+        valueSerializer.writeInt8((value_scheduleMarkerRadius_type).toChar())
+        if ((value_scheduleMarkerRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_scheduleMarkerRadius_value  = value_scheduleMarkerRadius!
+            valueSerializer.writeNumber(value_scheduleMarkerRadius_value)
+        }
+        const value_boundaryRowOffset  = value.boundaryRowOffset
+        let value_boundaryRowOffset_type : int32 = RuntimeType.UNDEFINED
+        value_boundaryRowOffset_type = runtimeType(value_boundaryRowOffset)
+        valueSerializer.writeInt8((value_boundaryRowOffset_type).toChar())
+        if ((value_boundaryRowOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_boundaryRowOffset_value  = value_boundaryRowOffset!
+            valueSerializer.writeNumber(value_boundaryRowOffset_value)
+        }
+        const value_boundaryColOffset  = value.boundaryColOffset
+        let value_boundaryColOffset_type : int32 = RuntimeType.UNDEFINED
+        value_boundaryColOffset_type = runtimeType(value_boundaryColOffset)
+        valueSerializer.writeInt8((value_boundaryColOffset_type).toChar())
+        if ((value_boundaryColOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_boundaryColOffset_value  = value_boundaryColOffset!
+            valueSerializer.writeNumber(value_boundaryColOffset_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): CurrentDayStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const dayColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dayColor_buf : ResourceColor | undefined
+        if ((dayColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const dayColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let dayColor_buf_ : Color | number | string | Resource | undefined
+            if (dayColor_buf__selector == (0).toChar()) {
+                dayColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (dayColor_buf__selector == (1).toChar()) {
+                dayColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (dayColor_buf__selector == (2).toChar()) {
+                dayColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (dayColor_buf__selector == (3).toChar()) {
+                dayColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for dayColor_buf_ has to be chosen through deserialisation.")
+            }
+            dayColor_buf = (dayColor_buf_ as Color | number | string | Resource)
+        }
+        const dayColor_result : ResourceColor | undefined = dayColor_buf
+        const lunarColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let lunarColor_buf : ResourceColor | undefined
+        if ((lunarColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const lunarColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let lunarColor_buf_ : Color | number | string | Resource | undefined
+            if (lunarColor_buf__selector == (0).toChar()) {
+                lunarColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (lunarColor_buf__selector == (1).toChar()) {
+                lunarColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (lunarColor_buf__selector == (2).toChar()) {
+                lunarColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (lunarColor_buf__selector == (3).toChar()) {
+                lunarColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for lunarColor_buf_ has to be chosen through deserialisation.")
+            }
+            lunarColor_buf = (lunarColor_buf_ as Color | number | string | Resource)
+        }
+        const lunarColor_result : ResourceColor | undefined = lunarColor_buf
+        const markLunarColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let markLunarColor_buf : ResourceColor | undefined
+        if ((markLunarColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const markLunarColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let markLunarColor_buf_ : Color | number | string | Resource | undefined
+            if (markLunarColor_buf__selector == (0).toChar()) {
+                markLunarColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (markLunarColor_buf__selector == (1).toChar()) {
+                markLunarColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (markLunarColor_buf__selector == (2).toChar()) {
+                markLunarColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (markLunarColor_buf__selector == (3).toChar()) {
+                markLunarColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for markLunarColor_buf_ has to be chosen through deserialisation.")
+            }
+            markLunarColor_buf = (markLunarColor_buf_ as Color | number | string | Resource)
+        }
+        const markLunarColor_result : ResourceColor | undefined = markLunarColor_buf
+        const dayFontSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dayFontSize_buf : number | undefined
+        if ((dayFontSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dayFontSize_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dayFontSize_result : number | undefined = dayFontSize_buf
+        const lunarDayFontSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let lunarDayFontSize_buf : number | undefined
+        if ((lunarDayFontSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            lunarDayFontSize_buf = (valueDeserializer.readNumber() as number)
+        }
+        const lunarDayFontSize_result : number | undefined = lunarDayFontSize_buf
+        const dayHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dayHeight_buf : number | undefined
+        if ((dayHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dayHeight_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dayHeight_result : number | undefined = dayHeight_buf
+        const dayWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dayWidth_buf : number | undefined
+        if ((dayWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dayWidth_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dayWidth_result : number | undefined = dayWidth_buf
+        const gregorianCalendarHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let gregorianCalendarHeight_buf : number | undefined
+        if ((gregorianCalendarHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            gregorianCalendarHeight_buf = (valueDeserializer.readNumber() as number)
+        }
+        const gregorianCalendarHeight_result : number | undefined = gregorianCalendarHeight_buf
+        const dayYAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dayYAxisOffset_buf : number | undefined
+        if ((dayYAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dayYAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dayYAxisOffset_result : number | undefined = dayYAxisOffset_buf
+        const lunarDayYAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let lunarDayYAxisOffset_buf : number | undefined
+        if ((lunarDayYAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            lunarDayYAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const lunarDayYAxisOffset_result : number | undefined = lunarDayYAxisOffset_buf
+        const underscoreXAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let underscoreXAxisOffset_buf : number | undefined
+        if ((underscoreXAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            underscoreXAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const underscoreXAxisOffset_result : number | undefined = underscoreXAxisOffset_buf
+        const underscoreYAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let underscoreYAxisOffset_buf : number | undefined
+        if ((underscoreYAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            underscoreYAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const underscoreYAxisOffset_result : number | undefined = underscoreYAxisOffset_buf
+        const scheduleMarkerXAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let scheduleMarkerXAxisOffset_buf : number | undefined
+        if ((scheduleMarkerXAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            scheduleMarkerXAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const scheduleMarkerXAxisOffset_result : number | undefined = scheduleMarkerXAxisOffset_buf
+        const scheduleMarkerYAxisOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let scheduleMarkerYAxisOffset_buf : number | undefined
+        if ((scheduleMarkerYAxisOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            scheduleMarkerYAxisOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const scheduleMarkerYAxisOffset_result : number | undefined = scheduleMarkerYAxisOffset_buf
+        const colSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let colSpace_buf : number | undefined
+        if ((colSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            colSpace_buf = (valueDeserializer.readNumber() as number)
+        }
+        const colSpace_result : number | undefined = colSpace_buf
+        const dailyFiveRowSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dailyFiveRowSpace_buf : number | undefined
+        if ((dailyFiveRowSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dailyFiveRowSpace_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dailyFiveRowSpace_result : number | undefined = dailyFiveRowSpace_buf
+        const dailySixRowSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dailySixRowSpace_buf : number | undefined
+        if ((dailySixRowSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dailySixRowSpace_buf = (valueDeserializer.readNumber() as number)
+        }
+        const dailySixRowSpace_result : number | undefined = dailySixRowSpace_buf
+        const lunarHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let lunarHeight_buf : number | undefined
+        if ((lunarHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            lunarHeight_buf = (valueDeserializer.readNumber() as number)
+        }
+        const lunarHeight_result : number | undefined = lunarHeight_buf
+        const underscoreWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let underscoreWidth_buf : number | undefined
+        if ((underscoreWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            underscoreWidth_buf = (valueDeserializer.readNumber() as number)
+        }
+        const underscoreWidth_result : number | undefined = underscoreWidth_buf
+        const underscoreLength_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let underscoreLength_buf : number | undefined
+        if ((underscoreLength_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            underscoreLength_buf = (valueDeserializer.readNumber() as number)
+        }
+        const underscoreLength_result : number | undefined = underscoreLength_buf
+        const scheduleMarkerRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let scheduleMarkerRadius_buf : number | undefined
+        if ((scheduleMarkerRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            scheduleMarkerRadius_buf = (valueDeserializer.readNumber() as number)
+        }
+        const scheduleMarkerRadius_result : number | undefined = scheduleMarkerRadius_buf
+        const boundaryRowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let boundaryRowOffset_buf : number | undefined
+        if ((boundaryRowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            boundaryRowOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const boundaryRowOffset_result : number | undefined = boundaryRowOffset_buf
+        const boundaryColOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let boundaryColOffset_buf : number | undefined
+        if ((boundaryColOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            boundaryColOffset_buf = (valueDeserializer.readNumber() as number)
+        }
+        const boundaryColOffset_result : number | undefined = boundaryColOffset_buf
+        let value : CurrentDayStyle = ({dayColor: dayColor_result, lunarColor: lunarColor_result, markLunarColor: markLunarColor_result, dayFontSize: dayFontSize_result, lunarDayFontSize: lunarDayFontSize_result, dayHeight: dayHeight_result, dayWidth: dayWidth_result, gregorianCalendarHeight: gregorianCalendarHeight_result, dayYAxisOffset: dayYAxisOffset_result, lunarDayYAxisOffset: lunarDayYAxisOffset_result, underscoreXAxisOffset: underscoreXAxisOffset_result, underscoreYAxisOffset: underscoreYAxisOffset_result, scheduleMarkerXAxisOffset: scheduleMarkerXAxisOffset_result, scheduleMarkerYAxisOffset: scheduleMarkerYAxisOffset_result, colSpace: colSpace_result, dailyFiveRowSpace: dailyFiveRowSpace_result, dailySixRowSpace: dailySixRowSpace_result, lunarHeight: lunarHeight_result, underscoreWidth: underscoreWidth_result, underscoreLength: underscoreLength_result, scheduleMarkerRadius: scheduleMarkerRadius_result, boundaryRowOffset: boundaryRowOffset_result, boundaryColOffset: boundaryColOffset_result} as CurrentDayStyle)
+        return value
+    }
+}
+export class NonCurrentDayStyle_serializer {
+    public static write(buffer: SerializerBase, value: NonCurrentDayStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_nonCurrentMonthDayColor  = value.nonCurrentMonthDayColor
+        let value_nonCurrentMonthDayColor_type : int32 = RuntimeType.UNDEFINED
+        value_nonCurrentMonthDayColor_type = runtimeType(value_nonCurrentMonthDayColor)
+        valueSerializer.writeInt8((value_nonCurrentMonthDayColor_type).toChar())
+        if ((value_nonCurrentMonthDayColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_nonCurrentMonthDayColor_value  = value_nonCurrentMonthDayColor!
+            let value_nonCurrentMonthDayColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_nonCurrentMonthDayColor_value_type = runtimeType(value_nonCurrentMonthDayColor_value)
+            if (TypeChecker.isColor(value_nonCurrentMonthDayColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_nonCurrentMonthDayColor_value_0  = value_nonCurrentMonthDayColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_nonCurrentMonthDayColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_nonCurrentMonthDayColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_nonCurrentMonthDayColor_value_1  = value_nonCurrentMonthDayColor_value as number
+                valueSerializer.writeNumber(value_nonCurrentMonthDayColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_nonCurrentMonthDayColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_nonCurrentMonthDayColor_value_2  = value_nonCurrentMonthDayColor_value as string
+                valueSerializer.writeString(value_nonCurrentMonthDayColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_nonCurrentMonthDayColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_nonCurrentMonthDayColor_value_3  = value_nonCurrentMonthDayColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_nonCurrentMonthDayColor_value_3)
+            }
+        }
+        const value_nonCurrentMonthLunarColor  = value.nonCurrentMonthLunarColor
+        let value_nonCurrentMonthLunarColor_type : int32 = RuntimeType.UNDEFINED
+        value_nonCurrentMonthLunarColor_type = runtimeType(value_nonCurrentMonthLunarColor)
+        valueSerializer.writeInt8((value_nonCurrentMonthLunarColor_type).toChar())
+        if ((value_nonCurrentMonthLunarColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_nonCurrentMonthLunarColor_value  = value_nonCurrentMonthLunarColor!
+            let value_nonCurrentMonthLunarColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_nonCurrentMonthLunarColor_value_type = runtimeType(value_nonCurrentMonthLunarColor_value)
+            if (TypeChecker.isColor(value_nonCurrentMonthLunarColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_nonCurrentMonthLunarColor_value_0  = value_nonCurrentMonthLunarColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_nonCurrentMonthLunarColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_nonCurrentMonthLunarColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_nonCurrentMonthLunarColor_value_1  = value_nonCurrentMonthLunarColor_value as number
+                valueSerializer.writeNumber(value_nonCurrentMonthLunarColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_nonCurrentMonthLunarColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_nonCurrentMonthLunarColor_value_2  = value_nonCurrentMonthLunarColor_value as string
+                valueSerializer.writeString(value_nonCurrentMonthLunarColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_nonCurrentMonthLunarColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_nonCurrentMonthLunarColor_value_3  = value_nonCurrentMonthLunarColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_nonCurrentMonthLunarColor_value_3)
+            }
+        }
+        const value_nonCurrentMonthWorkDayMarkColor  = value.nonCurrentMonthWorkDayMarkColor
+        let value_nonCurrentMonthWorkDayMarkColor_type : int32 = RuntimeType.UNDEFINED
+        value_nonCurrentMonthWorkDayMarkColor_type = runtimeType(value_nonCurrentMonthWorkDayMarkColor)
+        valueSerializer.writeInt8((value_nonCurrentMonthWorkDayMarkColor_type).toChar())
+        if ((value_nonCurrentMonthWorkDayMarkColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_nonCurrentMonthWorkDayMarkColor_value  = value_nonCurrentMonthWorkDayMarkColor!
+            let value_nonCurrentMonthWorkDayMarkColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_nonCurrentMonthWorkDayMarkColor_value_type = runtimeType(value_nonCurrentMonthWorkDayMarkColor_value)
+            if (TypeChecker.isColor(value_nonCurrentMonthWorkDayMarkColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_nonCurrentMonthWorkDayMarkColor_value_0  = value_nonCurrentMonthWorkDayMarkColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_nonCurrentMonthWorkDayMarkColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_nonCurrentMonthWorkDayMarkColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_nonCurrentMonthWorkDayMarkColor_value_1  = value_nonCurrentMonthWorkDayMarkColor_value as number
+                valueSerializer.writeNumber(value_nonCurrentMonthWorkDayMarkColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_nonCurrentMonthWorkDayMarkColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_nonCurrentMonthWorkDayMarkColor_value_2  = value_nonCurrentMonthWorkDayMarkColor_value as string
+                valueSerializer.writeString(value_nonCurrentMonthWorkDayMarkColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_nonCurrentMonthWorkDayMarkColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_nonCurrentMonthWorkDayMarkColor_value_3  = value_nonCurrentMonthWorkDayMarkColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_nonCurrentMonthWorkDayMarkColor_value_3)
+            }
+        }
+        const value_nonCurrentMonthOffDayMarkColor  = value.nonCurrentMonthOffDayMarkColor
+        let value_nonCurrentMonthOffDayMarkColor_type : int32 = RuntimeType.UNDEFINED
+        value_nonCurrentMonthOffDayMarkColor_type = runtimeType(value_nonCurrentMonthOffDayMarkColor)
+        valueSerializer.writeInt8((value_nonCurrentMonthOffDayMarkColor_type).toChar())
+        if ((value_nonCurrentMonthOffDayMarkColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_nonCurrentMonthOffDayMarkColor_value  = value_nonCurrentMonthOffDayMarkColor!
+            let value_nonCurrentMonthOffDayMarkColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_nonCurrentMonthOffDayMarkColor_value_type = runtimeType(value_nonCurrentMonthOffDayMarkColor_value)
+            if (TypeChecker.isColor(value_nonCurrentMonthOffDayMarkColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_nonCurrentMonthOffDayMarkColor_value_0  = value_nonCurrentMonthOffDayMarkColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_nonCurrentMonthOffDayMarkColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_nonCurrentMonthOffDayMarkColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_nonCurrentMonthOffDayMarkColor_value_1  = value_nonCurrentMonthOffDayMarkColor_value as number
+                valueSerializer.writeNumber(value_nonCurrentMonthOffDayMarkColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_nonCurrentMonthOffDayMarkColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_nonCurrentMonthOffDayMarkColor_value_2  = value_nonCurrentMonthOffDayMarkColor_value as string
+                valueSerializer.writeString(value_nonCurrentMonthOffDayMarkColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_nonCurrentMonthOffDayMarkColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_nonCurrentMonthOffDayMarkColor_value_3  = value_nonCurrentMonthOffDayMarkColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_nonCurrentMonthOffDayMarkColor_value_3)
+            }
+        }
+    }
+    public static read(buffer: DeserializerBase): NonCurrentDayStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const nonCurrentMonthDayColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let nonCurrentMonthDayColor_buf : ResourceColor | undefined
+        if ((nonCurrentMonthDayColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const nonCurrentMonthDayColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let nonCurrentMonthDayColor_buf_ : Color | number | string | Resource | undefined
+            if (nonCurrentMonthDayColor_buf__selector == (0).toChar()) {
+                nonCurrentMonthDayColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (nonCurrentMonthDayColor_buf__selector == (1).toChar()) {
+                nonCurrentMonthDayColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (nonCurrentMonthDayColor_buf__selector == (2).toChar()) {
+                nonCurrentMonthDayColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (nonCurrentMonthDayColor_buf__selector == (3).toChar()) {
+                nonCurrentMonthDayColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for nonCurrentMonthDayColor_buf_ has to be chosen through deserialisation.")
+            }
+            nonCurrentMonthDayColor_buf = (nonCurrentMonthDayColor_buf_ as Color | number | string | Resource)
+        }
+        const nonCurrentMonthDayColor_result : ResourceColor | undefined = nonCurrentMonthDayColor_buf
+        const nonCurrentMonthLunarColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let nonCurrentMonthLunarColor_buf : ResourceColor | undefined
+        if ((nonCurrentMonthLunarColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const nonCurrentMonthLunarColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let nonCurrentMonthLunarColor_buf_ : Color | number | string | Resource | undefined
+            if (nonCurrentMonthLunarColor_buf__selector == (0).toChar()) {
+                nonCurrentMonthLunarColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (nonCurrentMonthLunarColor_buf__selector == (1).toChar()) {
+                nonCurrentMonthLunarColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (nonCurrentMonthLunarColor_buf__selector == (2).toChar()) {
+                nonCurrentMonthLunarColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (nonCurrentMonthLunarColor_buf__selector == (3).toChar()) {
+                nonCurrentMonthLunarColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for nonCurrentMonthLunarColor_buf_ has to be chosen through deserialisation.")
+            }
+            nonCurrentMonthLunarColor_buf = (nonCurrentMonthLunarColor_buf_ as Color | number | string | Resource)
+        }
+        const nonCurrentMonthLunarColor_result : ResourceColor | undefined = nonCurrentMonthLunarColor_buf
+        const nonCurrentMonthWorkDayMarkColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let nonCurrentMonthWorkDayMarkColor_buf : ResourceColor | undefined
+        if ((nonCurrentMonthWorkDayMarkColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const nonCurrentMonthWorkDayMarkColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let nonCurrentMonthWorkDayMarkColor_buf_ : Color | number | string | Resource | undefined
+            if (nonCurrentMonthWorkDayMarkColor_buf__selector == (0).toChar()) {
+                nonCurrentMonthWorkDayMarkColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (nonCurrentMonthWorkDayMarkColor_buf__selector == (1).toChar()) {
+                nonCurrentMonthWorkDayMarkColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (nonCurrentMonthWorkDayMarkColor_buf__selector == (2).toChar()) {
+                nonCurrentMonthWorkDayMarkColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (nonCurrentMonthWorkDayMarkColor_buf__selector == (3).toChar()) {
+                nonCurrentMonthWorkDayMarkColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for nonCurrentMonthWorkDayMarkColor_buf_ has to be chosen through deserialisation.")
+            }
+            nonCurrentMonthWorkDayMarkColor_buf = (nonCurrentMonthWorkDayMarkColor_buf_ as Color | number | string | Resource)
+        }
+        const nonCurrentMonthWorkDayMarkColor_result : ResourceColor | undefined = nonCurrentMonthWorkDayMarkColor_buf
+        const nonCurrentMonthOffDayMarkColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let nonCurrentMonthOffDayMarkColor_buf : ResourceColor | undefined
+        if ((nonCurrentMonthOffDayMarkColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const nonCurrentMonthOffDayMarkColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let nonCurrentMonthOffDayMarkColor_buf_ : Color | number | string | Resource | undefined
+            if (nonCurrentMonthOffDayMarkColor_buf__selector == (0).toChar()) {
+                nonCurrentMonthOffDayMarkColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (nonCurrentMonthOffDayMarkColor_buf__selector == (1).toChar()) {
+                nonCurrentMonthOffDayMarkColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (nonCurrentMonthOffDayMarkColor_buf__selector == (2).toChar()) {
+                nonCurrentMonthOffDayMarkColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (nonCurrentMonthOffDayMarkColor_buf__selector == (3).toChar()) {
+                nonCurrentMonthOffDayMarkColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for nonCurrentMonthOffDayMarkColor_buf_ has to be chosen through deserialisation.")
+            }
+            nonCurrentMonthOffDayMarkColor_buf = (nonCurrentMonthOffDayMarkColor_buf_ as Color | number | string | Resource)
+        }
+        const nonCurrentMonthOffDayMarkColor_result : ResourceColor | undefined = nonCurrentMonthOffDayMarkColor_buf
+        let value : NonCurrentDayStyle = ({nonCurrentMonthDayColor: nonCurrentMonthDayColor_result, nonCurrentMonthLunarColor: nonCurrentMonthLunarColor_result, nonCurrentMonthWorkDayMarkColor: nonCurrentMonthWorkDayMarkColor_result, nonCurrentMonthOffDayMarkColor: nonCurrentMonthOffDayMarkColor_result} as NonCurrentDayStyle)
+        return value
+    }
+}
+export class TodayStyle_serializer {
+    public static write(buffer: SerializerBase, value: TodayStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_focusedDayColor  = value.focusedDayColor
+        let value_focusedDayColor_type : int32 = RuntimeType.UNDEFINED
+        value_focusedDayColor_type = runtimeType(value_focusedDayColor)
+        valueSerializer.writeInt8((value_focusedDayColor_type).toChar())
+        if ((value_focusedDayColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_focusedDayColor_value  = value_focusedDayColor!
+            let value_focusedDayColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_focusedDayColor_value_type = runtimeType(value_focusedDayColor_value)
+            if (TypeChecker.isColor(value_focusedDayColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_focusedDayColor_value_0  = value_focusedDayColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_focusedDayColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_focusedDayColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_focusedDayColor_value_1  = value_focusedDayColor_value as number
+                valueSerializer.writeNumber(value_focusedDayColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_focusedDayColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_focusedDayColor_value_2  = value_focusedDayColor_value as string
+                valueSerializer.writeString(value_focusedDayColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_focusedDayColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_focusedDayColor_value_3  = value_focusedDayColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_focusedDayColor_value_3)
+            }
+        }
+        const value_focusedLunarColor  = value.focusedLunarColor
+        let value_focusedLunarColor_type : int32 = RuntimeType.UNDEFINED
+        value_focusedLunarColor_type = runtimeType(value_focusedLunarColor)
+        valueSerializer.writeInt8((value_focusedLunarColor_type).toChar())
+        if ((value_focusedLunarColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_focusedLunarColor_value  = value_focusedLunarColor!
+            let value_focusedLunarColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_focusedLunarColor_value_type = runtimeType(value_focusedLunarColor_value)
+            if (TypeChecker.isColor(value_focusedLunarColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_focusedLunarColor_value_0  = value_focusedLunarColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_focusedLunarColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_focusedLunarColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_focusedLunarColor_value_1  = value_focusedLunarColor_value as number
+                valueSerializer.writeNumber(value_focusedLunarColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_focusedLunarColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_focusedLunarColor_value_2  = value_focusedLunarColor_value as string
+                valueSerializer.writeString(value_focusedLunarColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_focusedLunarColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_focusedLunarColor_value_3  = value_focusedLunarColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_focusedLunarColor_value_3)
+            }
+        }
+        const value_focusedAreaBackgroundColor  = value.focusedAreaBackgroundColor
+        let value_focusedAreaBackgroundColor_type : int32 = RuntimeType.UNDEFINED
+        value_focusedAreaBackgroundColor_type = runtimeType(value_focusedAreaBackgroundColor)
+        valueSerializer.writeInt8((value_focusedAreaBackgroundColor_type).toChar())
+        if ((value_focusedAreaBackgroundColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_focusedAreaBackgroundColor_value  = value_focusedAreaBackgroundColor!
+            let value_focusedAreaBackgroundColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_focusedAreaBackgroundColor_value_type = runtimeType(value_focusedAreaBackgroundColor_value)
+            if (TypeChecker.isColor(value_focusedAreaBackgroundColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_focusedAreaBackgroundColor_value_0  = value_focusedAreaBackgroundColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_focusedAreaBackgroundColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_focusedAreaBackgroundColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_focusedAreaBackgroundColor_value_1  = value_focusedAreaBackgroundColor_value as number
+                valueSerializer.writeNumber(value_focusedAreaBackgroundColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_focusedAreaBackgroundColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_focusedAreaBackgroundColor_value_2  = value_focusedAreaBackgroundColor_value as string
+                valueSerializer.writeString(value_focusedAreaBackgroundColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_focusedAreaBackgroundColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_focusedAreaBackgroundColor_value_3  = value_focusedAreaBackgroundColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_focusedAreaBackgroundColor_value_3)
+            }
+        }
+        const value_focusedAreaRadius  = value.focusedAreaRadius
+        let value_focusedAreaRadius_type : int32 = RuntimeType.UNDEFINED
+        value_focusedAreaRadius_type = runtimeType(value_focusedAreaRadius)
+        valueSerializer.writeInt8((value_focusedAreaRadius_type).toChar())
+        if ((value_focusedAreaRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_focusedAreaRadius_value  = value_focusedAreaRadius!
+            valueSerializer.writeNumber(value_focusedAreaRadius_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): TodayStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const focusedDayColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focusedDayColor_buf : ResourceColor | undefined
+        if ((focusedDayColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const focusedDayColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let focusedDayColor_buf_ : Color | number | string | Resource | undefined
+            if (focusedDayColor_buf__selector == (0).toChar()) {
+                focusedDayColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (focusedDayColor_buf__selector == (1).toChar()) {
+                focusedDayColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (focusedDayColor_buf__selector == (2).toChar()) {
+                focusedDayColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (focusedDayColor_buf__selector == (3).toChar()) {
+                focusedDayColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for focusedDayColor_buf_ has to be chosen through deserialisation.")
+            }
+            focusedDayColor_buf = (focusedDayColor_buf_ as Color | number | string | Resource)
+        }
+        const focusedDayColor_result : ResourceColor | undefined = focusedDayColor_buf
+        const focusedLunarColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focusedLunarColor_buf : ResourceColor | undefined
+        if ((focusedLunarColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const focusedLunarColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let focusedLunarColor_buf_ : Color | number | string | Resource | undefined
+            if (focusedLunarColor_buf__selector == (0).toChar()) {
+                focusedLunarColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (focusedLunarColor_buf__selector == (1).toChar()) {
+                focusedLunarColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (focusedLunarColor_buf__selector == (2).toChar()) {
+                focusedLunarColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (focusedLunarColor_buf__selector == (3).toChar()) {
+                focusedLunarColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for focusedLunarColor_buf_ has to be chosen through deserialisation.")
+            }
+            focusedLunarColor_buf = (focusedLunarColor_buf_ as Color | number | string | Resource)
+        }
+        const focusedLunarColor_result : ResourceColor | undefined = focusedLunarColor_buf
+        const focusedAreaBackgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focusedAreaBackgroundColor_buf : ResourceColor | undefined
+        if ((focusedAreaBackgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const focusedAreaBackgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let focusedAreaBackgroundColor_buf_ : Color | number | string | Resource | undefined
+            if (focusedAreaBackgroundColor_buf__selector == (0).toChar()) {
+                focusedAreaBackgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (focusedAreaBackgroundColor_buf__selector == (1).toChar()) {
+                focusedAreaBackgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (focusedAreaBackgroundColor_buf__selector == (2).toChar()) {
+                focusedAreaBackgroundColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (focusedAreaBackgroundColor_buf__selector == (3).toChar()) {
+                focusedAreaBackgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for focusedAreaBackgroundColor_buf_ has to be chosen through deserialisation.")
+            }
+            focusedAreaBackgroundColor_buf = (focusedAreaBackgroundColor_buf_ as Color | number | string | Resource)
+        }
+        const focusedAreaBackgroundColor_result : ResourceColor | undefined = focusedAreaBackgroundColor_buf
+        const focusedAreaRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focusedAreaRadius_buf : number | undefined
+        if ((focusedAreaRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            focusedAreaRadius_buf = (valueDeserializer.readNumber() as number)
+        }
+        const focusedAreaRadius_result : number | undefined = focusedAreaRadius_buf
+        let value : TodayStyle = ({focusedDayColor: focusedDayColor_result, focusedLunarColor: focusedLunarColor_result, focusedAreaBackgroundColor: focusedAreaBackgroundColor_result, focusedAreaRadius: focusedAreaRadius_result} as TodayStyle)
+        return value
+    }
+}
+export class WeekStyle_serializer {
+    public static write(buffer: SerializerBase, value: WeekStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_weekColor  = value.weekColor
+        let value_weekColor_type : int32 = RuntimeType.UNDEFINED
+        value_weekColor_type = runtimeType(value_weekColor)
+        valueSerializer.writeInt8((value_weekColor_type).toChar())
+        if ((value_weekColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekColor_value  = value_weekColor!
+            let value_weekColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_weekColor_value_type = runtimeType(value_weekColor_value)
+            if (TypeChecker.isColor(value_weekColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_weekColor_value_0  = value_weekColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_weekColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_weekColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_weekColor_value_1  = value_weekColor_value as number
+                valueSerializer.writeNumber(value_weekColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_weekColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_weekColor_value_2  = value_weekColor_value as string
+                valueSerializer.writeString(value_weekColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_weekColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_weekColor_value_3  = value_weekColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_weekColor_value_3)
+            }
+        }
+        const value_weekendDayColor  = value.weekendDayColor
+        let value_weekendDayColor_type : int32 = RuntimeType.UNDEFINED
+        value_weekendDayColor_type = runtimeType(value_weekendDayColor)
+        valueSerializer.writeInt8((value_weekendDayColor_type).toChar())
+        if ((value_weekendDayColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekendDayColor_value  = value_weekendDayColor!
+            let value_weekendDayColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_weekendDayColor_value_type = runtimeType(value_weekendDayColor_value)
+            if (TypeChecker.isColor(value_weekendDayColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_weekendDayColor_value_0  = value_weekendDayColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_weekendDayColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_weekendDayColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_weekendDayColor_value_1  = value_weekendDayColor_value as number
+                valueSerializer.writeNumber(value_weekendDayColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_weekendDayColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_weekendDayColor_value_2  = value_weekendDayColor_value as string
+                valueSerializer.writeString(value_weekendDayColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_weekendDayColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_weekendDayColor_value_3  = value_weekendDayColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_weekendDayColor_value_3)
+            }
+        }
+        const value_weekendLunarColor  = value.weekendLunarColor
+        let value_weekendLunarColor_type : int32 = RuntimeType.UNDEFINED
+        value_weekendLunarColor_type = runtimeType(value_weekendLunarColor)
+        valueSerializer.writeInt8((value_weekendLunarColor_type).toChar())
+        if ((value_weekendLunarColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekendLunarColor_value  = value_weekendLunarColor!
+            let value_weekendLunarColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_weekendLunarColor_value_type = runtimeType(value_weekendLunarColor_value)
+            if (TypeChecker.isColor(value_weekendLunarColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_weekendLunarColor_value_0  = value_weekendLunarColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_weekendLunarColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_weekendLunarColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_weekendLunarColor_value_1  = value_weekendLunarColor_value as number
+                valueSerializer.writeNumber(value_weekendLunarColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_weekendLunarColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_weekendLunarColor_value_2  = value_weekendLunarColor_value as string
+                valueSerializer.writeString(value_weekendLunarColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_weekendLunarColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_weekendLunarColor_value_3  = value_weekendLunarColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_weekendLunarColor_value_3)
+            }
+        }
+        const value_weekFontSize  = value.weekFontSize
+        let value_weekFontSize_type : int32 = RuntimeType.UNDEFINED
+        value_weekFontSize_type = runtimeType(value_weekFontSize)
+        valueSerializer.writeInt8((value_weekFontSize_type).toChar())
+        if ((value_weekFontSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekFontSize_value  = value_weekFontSize!
+            valueSerializer.writeNumber(value_weekFontSize_value)
+        }
+        const value_weekHeight  = value.weekHeight
+        let value_weekHeight_type : int32 = RuntimeType.UNDEFINED
+        value_weekHeight_type = runtimeType(value_weekHeight)
+        valueSerializer.writeInt8((value_weekHeight_type).toChar())
+        if ((value_weekHeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekHeight_value  = value_weekHeight!
+            valueSerializer.writeNumber(value_weekHeight_value)
+        }
+        const value_weekWidth  = value.weekWidth
+        let value_weekWidth_type : int32 = RuntimeType.UNDEFINED
+        value_weekWidth_type = runtimeType(value_weekWidth)
+        valueSerializer.writeInt8((value_weekWidth_type).toChar())
+        if ((value_weekWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekWidth_value  = value_weekWidth!
+            valueSerializer.writeNumber(value_weekWidth_value)
+        }
+        const value_weekAndDayRowSpace  = value.weekAndDayRowSpace
+        let value_weekAndDayRowSpace_type : int32 = RuntimeType.UNDEFINED
+        value_weekAndDayRowSpace_type = runtimeType(value_weekAndDayRowSpace)
+        valueSerializer.writeInt8((value_weekAndDayRowSpace_type).toChar())
+        if ((value_weekAndDayRowSpace_type) != (RuntimeType.UNDEFINED)) {
+            const value_weekAndDayRowSpace_value  = value_weekAndDayRowSpace!
+            valueSerializer.writeNumber(value_weekAndDayRowSpace_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): WeekStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const weekColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekColor_buf : ResourceColor | undefined
+        if ((weekColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const weekColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let weekColor_buf_ : Color | number | string | Resource | undefined
+            if (weekColor_buf__selector == (0).toChar()) {
+                weekColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (weekColor_buf__selector == (1).toChar()) {
+                weekColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (weekColor_buf__selector == (2).toChar()) {
+                weekColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (weekColor_buf__selector == (3).toChar()) {
+                weekColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for weekColor_buf_ has to be chosen through deserialisation.")
+            }
+            weekColor_buf = (weekColor_buf_ as Color | number | string | Resource)
+        }
+        const weekColor_result : ResourceColor | undefined = weekColor_buf
+        const weekendDayColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekendDayColor_buf : ResourceColor | undefined
+        if ((weekendDayColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const weekendDayColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let weekendDayColor_buf_ : Color | number | string | Resource | undefined
+            if (weekendDayColor_buf__selector == (0).toChar()) {
+                weekendDayColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (weekendDayColor_buf__selector == (1).toChar()) {
+                weekendDayColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (weekendDayColor_buf__selector == (2).toChar()) {
+                weekendDayColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (weekendDayColor_buf__selector == (3).toChar()) {
+                weekendDayColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for weekendDayColor_buf_ has to be chosen through deserialisation.")
+            }
+            weekendDayColor_buf = (weekendDayColor_buf_ as Color | number | string | Resource)
+        }
+        const weekendDayColor_result : ResourceColor | undefined = weekendDayColor_buf
+        const weekendLunarColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekendLunarColor_buf : ResourceColor | undefined
+        if ((weekendLunarColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const weekendLunarColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let weekendLunarColor_buf_ : Color | number | string | Resource | undefined
+            if (weekendLunarColor_buf__selector == (0).toChar()) {
+                weekendLunarColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (weekendLunarColor_buf__selector == (1).toChar()) {
+                weekendLunarColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (weekendLunarColor_buf__selector == (2).toChar()) {
+                weekendLunarColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (weekendLunarColor_buf__selector == (3).toChar()) {
+                weekendLunarColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for weekendLunarColor_buf_ has to be chosen through deserialisation.")
+            }
+            weekendLunarColor_buf = (weekendLunarColor_buf_ as Color | number | string | Resource)
+        }
+        const weekendLunarColor_result : ResourceColor | undefined = weekendLunarColor_buf
+        const weekFontSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekFontSize_buf : number | undefined
+        if ((weekFontSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            weekFontSize_buf = (valueDeserializer.readNumber() as number)
+        }
+        const weekFontSize_result : number | undefined = weekFontSize_buf
+        const weekHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekHeight_buf : number | undefined
+        if ((weekHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            weekHeight_buf = (valueDeserializer.readNumber() as number)
+        }
+        const weekHeight_result : number | undefined = weekHeight_buf
+        const weekWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekWidth_buf : number | undefined
+        if ((weekWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            weekWidth_buf = (valueDeserializer.readNumber() as number)
+        }
+        const weekWidth_result : number | undefined = weekWidth_buf
+        const weekAndDayRowSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let weekAndDayRowSpace_buf : number | undefined
+        if ((weekAndDayRowSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            weekAndDayRowSpace_buf = (valueDeserializer.readNumber() as number)
+        }
+        const weekAndDayRowSpace_result : number | undefined = weekAndDayRowSpace_buf
+        let value : WeekStyle = ({weekColor: weekColor_result, weekendDayColor: weekendDayColor_result, weekendLunarColor: weekendLunarColor_result, weekFontSize: weekFontSize_result, weekHeight: weekHeight_result, weekWidth: weekWidth_result, weekAndDayRowSpace: weekAndDayRowSpace_result} as WeekStyle)
+        return value
+    }
+}
+export class WorkStateStyle_serializer {
+    public static write(buffer: SerializerBase, value: WorkStateStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_workDayMarkColor  = value.workDayMarkColor
+        let value_workDayMarkColor_type : int32 = RuntimeType.UNDEFINED
+        value_workDayMarkColor_type = runtimeType(value_workDayMarkColor)
+        valueSerializer.writeInt8((value_workDayMarkColor_type).toChar())
+        if ((value_workDayMarkColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_workDayMarkColor_value  = value_workDayMarkColor!
+            let value_workDayMarkColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_workDayMarkColor_value_type = runtimeType(value_workDayMarkColor_value)
+            if (TypeChecker.isColor(value_workDayMarkColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_workDayMarkColor_value_0  = value_workDayMarkColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_workDayMarkColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_workDayMarkColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_workDayMarkColor_value_1  = value_workDayMarkColor_value as number
+                valueSerializer.writeNumber(value_workDayMarkColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_workDayMarkColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_workDayMarkColor_value_2  = value_workDayMarkColor_value as string
+                valueSerializer.writeString(value_workDayMarkColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_workDayMarkColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_workDayMarkColor_value_3  = value_workDayMarkColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_workDayMarkColor_value_3)
+            }
+        }
+        const value_offDayMarkColor  = value.offDayMarkColor
+        let value_offDayMarkColor_type : int32 = RuntimeType.UNDEFINED
+        value_offDayMarkColor_type = runtimeType(value_offDayMarkColor)
+        valueSerializer.writeInt8((value_offDayMarkColor_type).toChar())
+        if ((value_offDayMarkColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_offDayMarkColor_value  = value_offDayMarkColor!
+            let value_offDayMarkColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_offDayMarkColor_value_type = runtimeType(value_offDayMarkColor_value)
+            if (TypeChecker.isColor(value_offDayMarkColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_offDayMarkColor_value_0  = value_offDayMarkColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_offDayMarkColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_offDayMarkColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_offDayMarkColor_value_1  = value_offDayMarkColor_value as number
+                valueSerializer.writeNumber(value_offDayMarkColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_offDayMarkColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_offDayMarkColor_value_2  = value_offDayMarkColor_value as string
+                valueSerializer.writeString(value_offDayMarkColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_offDayMarkColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_offDayMarkColor_value_3  = value_offDayMarkColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_offDayMarkColor_value_3)
+            }
+        }
+        const value_workDayMarkSize  = value.workDayMarkSize
+        let value_workDayMarkSize_type : int32 = RuntimeType.UNDEFINED
+        value_workDayMarkSize_type = runtimeType(value_workDayMarkSize)
+        valueSerializer.writeInt8((value_workDayMarkSize_type).toChar())
+        if ((value_workDayMarkSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_workDayMarkSize_value  = value_workDayMarkSize!
+            valueSerializer.writeNumber(value_workDayMarkSize_value)
+        }
+        const value_offDayMarkSize  = value.offDayMarkSize
+        let value_offDayMarkSize_type : int32 = RuntimeType.UNDEFINED
+        value_offDayMarkSize_type = runtimeType(value_offDayMarkSize)
+        valueSerializer.writeInt8((value_offDayMarkSize_type).toChar())
+        if ((value_offDayMarkSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_offDayMarkSize_value  = value_offDayMarkSize!
+            valueSerializer.writeNumber(value_offDayMarkSize_value)
+        }
+        const value_workStateWidth  = value.workStateWidth
+        let value_workStateWidth_type : int32 = RuntimeType.UNDEFINED
+        value_workStateWidth_type = runtimeType(value_workStateWidth)
+        valueSerializer.writeInt8((value_workStateWidth_type).toChar())
+        if ((value_workStateWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_workStateWidth_value  = value_workStateWidth!
+            valueSerializer.writeNumber(value_workStateWidth_value)
+        }
+        const value_workStateHorizontalMovingDistance  = value.workStateHorizontalMovingDistance
+        let value_workStateHorizontalMovingDistance_type : int32 = RuntimeType.UNDEFINED
+        value_workStateHorizontalMovingDistance_type = runtimeType(value_workStateHorizontalMovingDistance)
+        valueSerializer.writeInt8((value_workStateHorizontalMovingDistance_type).toChar())
+        if ((value_workStateHorizontalMovingDistance_type) != (RuntimeType.UNDEFINED)) {
+            const value_workStateHorizontalMovingDistance_value  = value_workStateHorizontalMovingDistance!
+            valueSerializer.writeNumber(value_workStateHorizontalMovingDistance_value)
+        }
+        const value_workStateVerticalMovingDistance  = value.workStateVerticalMovingDistance
+        let value_workStateVerticalMovingDistance_type : int32 = RuntimeType.UNDEFINED
+        value_workStateVerticalMovingDistance_type = runtimeType(value_workStateVerticalMovingDistance)
+        valueSerializer.writeInt8((value_workStateVerticalMovingDistance_type).toChar())
+        if ((value_workStateVerticalMovingDistance_type) != (RuntimeType.UNDEFINED)) {
+            const value_workStateVerticalMovingDistance_value  = value_workStateVerticalMovingDistance!
+            valueSerializer.writeNumber(value_workStateVerticalMovingDistance_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): WorkStateStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const workDayMarkColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let workDayMarkColor_buf : ResourceColor | undefined
+        if ((workDayMarkColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const workDayMarkColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let workDayMarkColor_buf_ : Color | number | string | Resource | undefined
+            if (workDayMarkColor_buf__selector == (0).toChar()) {
+                workDayMarkColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (workDayMarkColor_buf__selector == (1).toChar()) {
+                workDayMarkColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (workDayMarkColor_buf__selector == (2).toChar()) {
+                workDayMarkColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (workDayMarkColor_buf__selector == (3).toChar()) {
+                workDayMarkColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for workDayMarkColor_buf_ has to be chosen through deserialisation.")
+            }
+            workDayMarkColor_buf = (workDayMarkColor_buf_ as Color | number | string | Resource)
+        }
+        const workDayMarkColor_result : ResourceColor | undefined = workDayMarkColor_buf
+        const offDayMarkColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offDayMarkColor_buf : ResourceColor | undefined
+        if ((offDayMarkColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const offDayMarkColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let offDayMarkColor_buf_ : Color | number | string | Resource | undefined
+            if (offDayMarkColor_buf__selector == (0).toChar()) {
+                offDayMarkColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (offDayMarkColor_buf__selector == (1).toChar()) {
+                offDayMarkColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (offDayMarkColor_buf__selector == (2).toChar()) {
+                offDayMarkColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (offDayMarkColor_buf__selector == (3).toChar()) {
+                offDayMarkColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for offDayMarkColor_buf_ has to be chosen through deserialisation.")
+            }
+            offDayMarkColor_buf = (offDayMarkColor_buf_ as Color | number | string | Resource)
+        }
+        const offDayMarkColor_result : ResourceColor | undefined = offDayMarkColor_buf
+        const workDayMarkSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let workDayMarkSize_buf : number | undefined
+        if ((workDayMarkSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            workDayMarkSize_buf = (valueDeserializer.readNumber() as number)
+        }
+        const workDayMarkSize_result : number | undefined = workDayMarkSize_buf
+        const offDayMarkSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offDayMarkSize_buf : number | undefined
+        if ((offDayMarkSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            offDayMarkSize_buf = (valueDeserializer.readNumber() as number)
+        }
+        const offDayMarkSize_result : number | undefined = offDayMarkSize_buf
+        const workStateWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let workStateWidth_buf : number | undefined
+        if ((workStateWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            workStateWidth_buf = (valueDeserializer.readNumber() as number)
+        }
+        const workStateWidth_result : number | undefined = workStateWidth_buf
+        const workStateHorizontalMovingDistance_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let workStateHorizontalMovingDistance_buf : number | undefined
+        if ((workStateHorizontalMovingDistance_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            workStateHorizontalMovingDistance_buf = (valueDeserializer.readNumber() as number)
+        }
+        const workStateHorizontalMovingDistance_result : number | undefined = workStateHorizontalMovingDistance_buf
+        const workStateVerticalMovingDistance_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let workStateVerticalMovingDistance_buf : number | undefined
+        if ((workStateVerticalMovingDistance_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            workStateVerticalMovingDistance_buf = (valueDeserializer.readNumber() as number)
+        }
+        const workStateVerticalMovingDistance_result : number | undefined = workStateVerticalMovingDistance_buf
+        let value : WorkStateStyle = ({workDayMarkColor: workDayMarkColor_result, offDayMarkColor: offDayMarkColor_result, workDayMarkSize: workDayMarkSize_result, offDayMarkSize: offDayMarkSize_result, workStateWidth: workStateWidth_result, workStateHorizontalMovingDistance: workStateHorizontalMovingDistance_result, workStateVerticalMovingDistance: workStateVerticalMovingDistance_result} as WorkStateStyle)
+        return value
+    }
+}
diff --git a/arkoala-arkts/arkui/src/component/common.ets b/arkoala-arkts/arkui/src/component/common.ets
index 4d79d94c7d..72f74c90d8 100644
--- a/arkoala-arkts/arkui/src/component/common.ets
+++ b/arkoala-arkts/arkui/src/component/common.ets
@@ -48,7 +48,7 @@ import { ComponentBuilder } from "@koalaui/builderLambda"
 import { Context } from "./../generated/application.Context"
 import { pointer } from "./../generated/ohos.multimodalInput.pointer"
 import { ButtonType, ButtonStyleMode, ButtonRole } from "./button"
-import { ContentModifier, CustomStyles, UICommonBase, AttributeModifier, AttributeUpdater } from "./../handwritten"
+import { ContentModifier, UICommonBase, AttributeModifier, AttributeUpdater } from "./../handwritten"
 import { promptAction } from "./../generated/ohos.promptAction"
 import { ScrollState } from "./list"
 import { Want, Want_serializer } from "./../generated/ohos.app.ability.Want"
@@ -2008,29 +2008,29 @@ export class TransitionEffect implements MaterializedBase {
     public getPeer(): Finalizable | undefined {
         return this.peer
     }
-    get IDENTITY(): TransitionEffect {
-        return this.getIDENTITY()
+    static get IDENTITY(): TransitionEffect {
+        return TransitionEffect.getIDENTITY()
     }
-    set IDENTITY(IDENTITY: TransitionEffect) {
-        this.setIDENTITY(IDENTITY)
+    static set IDENTITY(IDENTITY: TransitionEffect) {
+        TransitionEffect.setIDENTITY(IDENTITY)
     }
-    get OPACITY(): TransitionEffect {
-        return this.getOPACITY()
+    static get OPACITY(): TransitionEffect {
+        return TransitionEffect.getOPACITY()
     }
-    set OPACITY(OPACITY: TransitionEffect) {
-        this.setOPACITY(OPACITY)
+    static set OPACITY(OPACITY: TransitionEffect) {
+        TransitionEffect.setOPACITY(OPACITY)
     }
-    get SLIDE(): TransitionEffect {
-        return this.getSLIDE()
+    static get SLIDE(): TransitionEffect {
+        return TransitionEffect.getSLIDE()
     }
-    set SLIDE(SLIDE: TransitionEffect) {
-        this.setSLIDE(SLIDE)
+    static set SLIDE(SLIDE: TransitionEffect) {
+        TransitionEffect.setSLIDE(SLIDE)
     }
-    get SLIDE_SWITCH(): TransitionEffect {
-        return this.getSLIDE_SWITCH()
+    static get SLIDE_SWITCH(): TransitionEffect {
+        return TransitionEffect.getSLIDE_SWITCH()
     }
-    set SLIDE_SWITCH(SLIDE_SWITCH: TransitionEffect) {
-        this.setSLIDE_SWITCH(SLIDE_SWITCH)
+    static set SLIDE_SWITCH(SLIDE_SWITCH: TransitionEffect) {
+        TransitionEffect.setSLIDE_SWITCH(SLIDE_SWITCH)
     }
     constructor(_0: boolean, peerPtr: KPointer) {
         this.peer = new Finalizable(peerPtr, TransitionEffect.getFinalizer())
@@ -2138,6 +2138,38 @@ export class TransitionEffect implements MaterializedBase {
         const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
         return obj
     }
+    private static getIDENTITY_serialize(): TransitionEffect {
+        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getIDENTITY()
+        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
+        return obj
+    }
+    private static setIDENTITY_serialize(IDENTITY: TransitionEffect): void {
+        ArkUIGeneratedNativeModule._TransitionEffect_setIDENTITY(toPeerPtr(IDENTITY))
+    }
+    private static getOPACITY_serialize(): TransitionEffect {
+        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getOPACITY()
+        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
+        return obj
+    }
+    private static setOPACITY_serialize(OPACITY: TransitionEffect): void {
+        ArkUIGeneratedNativeModule._TransitionEffect_setOPACITY(toPeerPtr(OPACITY))
+    }
+    private static getSLIDE_serialize(): TransitionEffect {
+        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getSLIDE()
+        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
+        return obj
+    }
+    private static setSLIDE_serialize(SLIDE: TransitionEffect): void {
+        ArkUIGeneratedNativeModule._TransitionEffect_setSLIDE(toPeerPtr(SLIDE))
+    }
+    private static getSLIDE_SWITCH_serialize(): TransitionEffect {
+        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getSLIDE_SWITCH()
+        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
+        return obj
+    }
+    private static setSLIDE_SWITCH_serialize(SLIDE_SWITCH: TransitionEffect): void {
+        ArkUIGeneratedNativeModule._TransitionEffect_setSLIDE_SWITCH(toPeerPtr(SLIDE_SWITCH))
+    }
     public static translate(options: TranslateOptions): TransitionEffect {
         const options_casted = options as (TranslateOptions)
         return TransitionEffect.translate_serialize(options_casted)
@@ -2171,36 +2203,36 @@ export class TransitionEffect implements MaterializedBase {
         const transitionEffect_casted = transitionEffect as (TransitionEffect)
         return this.combine_serialize(transitionEffect_casted)
     }
-    private getIDENTITY(): TransitionEffect {
-        return this.getIDENTITY_serialize()
+    private static getIDENTITY(): TransitionEffect {
+        return TransitionEffect.getIDENTITY_serialize()
     }
-    private setIDENTITY(IDENTITY: TransitionEffect): void {
+    private static setIDENTITY(IDENTITY: TransitionEffect): void {
         const IDENTITY_casted = IDENTITY as (TransitionEffect)
-        this.setIDENTITY_serialize(IDENTITY_casted)
+        TransitionEffect.setIDENTITY_serialize(IDENTITY_casted)
         return
     }
-    private getOPACITY(): TransitionEffect {
-        return this.getOPACITY_serialize()
+    private static getOPACITY(): TransitionEffect {
+        return TransitionEffect.getOPACITY_serialize()
     }
-    private setOPACITY(OPACITY: TransitionEffect): void {
+    private static setOPACITY(OPACITY: TransitionEffect): void {
         const OPACITY_casted = OPACITY as (TransitionEffect)
-        this.setOPACITY_serialize(OPACITY_casted)
+        TransitionEffect.setOPACITY_serialize(OPACITY_casted)
         return
     }
-    private getSLIDE(): TransitionEffect {
-        return this.getSLIDE_serialize()
+    private static getSLIDE(): TransitionEffect {
+        return TransitionEffect.getSLIDE_serialize()
     }
-    private setSLIDE(SLIDE: TransitionEffect): void {
+    private static setSLIDE(SLIDE: TransitionEffect): void {
         const SLIDE_casted = SLIDE as (TransitionEffect)
-        this.setSLIDE_serialize(SLIDE_casted)
+        TransitionEffect.setSLIDE_serialize(SLIDE_casted)
         return
     }
-    private getSLIDE_SWITCH(): TransitionEffect {
-        return this.getSLIDE_SWITCH_serialize()
+    private static getSLIDE_SWITCH(): TransitionEffect {
+        return TransitionEffect.getSLIDE_SWITCH_serialize()
     }
-    private setSLIDE_SWITCH(SLIDE_SWITCH: TransitionEffect): void {
+    private static setSLIDE_SWITCH(SLIDE_SWITCH: TransitionEffect): void {
         const SLIDE_SWITCH_casted = SLIDE_SWITCH as (TransitionEffect)
-        this.setSLIDE_SWITCH_serialize(SLIDE_SWITCH_casted)
+        TransitionEffect.setSLIDE_SWITCH_serialize(SLIDE_SWITCH_casted)
         return
     }
     private animation_serialize(value: AnimateParam): TransitionEffect {
@@ -2216,38 +2248,6 @@ export class TransitionEffect implements MaterializedBase {
         const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
         return obj
     }
-    private getIDENTITY_serialize(): TransitionEffect {
-        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getIDENTITY(this.peer!.ptr)
-        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
-        return obj
-    }
-    private setIDENTITY_serialize(IDENTITY: TransitionEffect): void {
-        ArkUIGeneratedNativeModule._TransitionEffect_setIDENTITY(this.peer!.ptr, toPeerPtr(IDENTITY))
-    }
-    private getOPACITY_serialize(): TransitionEffect {
-        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getOPACITY(this.peer!.ptr)
-        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
-        return obj
-    }
-    private setOPACITY_serialize(OPACITY: TransitionEffect): void {
-        ArkUIGeneratedNativeModule._TransitionEffect_setOPACITY(this.peer!.ptr, toPeerPtr(OPACITY))
-    }
-    private getSLIDE_serialize(): TransitionEffect {
-        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getSLIDE(this.peer!.ptr)
-        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
-        return obj
-    }
-    private setSLIDE_serialize(SLIDE: TransitionEffect): void {
-        ArkUIGeneratedNativeModule._TransitionEffect_setSLIDE(this.peer!.ptr, toPeerPtr(SLIDE))
-    }
-    private getSLIDE_SWITCH_serialize(): TransitionEffect {
-        const retval  = ArkUIGeneratedNativeModule._TransitionEffect_getSLIDE_SWITCH(this.peer!.ptr)
-        const obj : TransitionEffect = TransitionEffectInternal.fromPtr(retval)
-        return obj
-    }
-    private setSLIDE_SWITCH_serialize(SLIDE_SWITCH: TransitionEffect): void {
-        ArkUIGeneratedNativeModule._TransitionEffect_setSLIDE_SWITCH(this.peer!.ptr, toPeerPtr(SLIDE_SWITCH))
-    }
 }
 export interface UICommonEvent {
     setOnClick(callback_: ((event: ClickEvent) => void) | undefined): void
@@ -4613,7 +4613,16 @@ export class ArkCommonMethodPeer extends PeerNode {
         thisSerializer.release()
     }
     setStateStylesAttribute(value: StateStyles | undefined): void {
-        throw new Error("Not implemented")
+        const thisSerializer : SerializerBase = SerializerBase.hold()
+        let value_type : int32 = RuntimeType.UNDEFINED
+        value_type = runtimeType(value)
+        thisSerializer.writeInt8((value_type).toChar())
+        if ((value_type) != (RuntimeType.UNDEFINED)) {
+            const value_value  = value!
+            StateStyles_serializer.write(thisSerializer, value_value)
+        }
+        ArkUIGeneratedNativeModule._CommonMethod_setStateStyles(this.peer.ptr, thisSerializer.asBuffer(), thisSerializer.length())
+        thisSerializer.release()
     }
     setRestoreIdAttribute(value: number | undefined): void {
         const thisSerializer : SerializerBase = SerializerBase.hold()
@@ -7335,6 +7344,7 @@ export interface SheetOptions extends BindOptions {
     placement?: Placement;
     placementOnTarget?: boolean;
 }
+export type CustomStyles = (instance: string) => void;
 export interface StateStyles {
     normal?: CustomStyles;
     pressed?: CustomStyles;
@@ -13839,6 +13849,17 @@ export class TouchTestInfo_serializer {
         return value
     }
 }
+export class TransitionEffect_serializer {
+    public static write(buffer: SerializerBase, value: TransitionEffect): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): TransitionEffect {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return TransitionEffectInternal.fromPtr(ptr)
+    }
+}
 export class UICommonEvent_serializer {
     public static write(buffer: SerializerBase, value: UICommonEvent): void {
         let valueSerializer : SerializerBase = buffer
@@ -13870,6 +13891,22 @@ export class AlignRuleOption_serializer {
         return value
     }
 }
+export class AsymmetricTransitionOption_serializer {
+    public static write(buffer: SerializerBase, value: AsymmetricTransitionOption): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_appear  = value.appear
+        TransitionEffect_serializer.write(valueSerializer, value_appear)
+        const value_disappear  = value.disappear
+        TransitionEffect_serializer.write(valueSerializer, value_disappear)
+    }
+    public static read(buffer: DeserializerBase): AsymmetricTransitionOption {
+        let valueDeserializer : DeserializerBase = buffer
+        const appear_result : TransitionEffect = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+        const disappear_result : TransitionEffect = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+        let value : AsymmetricTransitionOption = ({appear: appear_result, disappear: disappear_result} as AsymmetricTransitionOption)
+        return value
+    }
+}
 export class BackgroundBrightnessOptions_serializer {
     public static write(buffer: SerializerBase, value: BackgroundBrightnessOptions): void {
         let valueSerializer : SerializerBase = buffer
@@ -15522,6 +15559,172 @@ export class SpringBackAction_serializer {
         return value
     }
 }
+export class StateStyles_serializer {
+    public static write(buffer: SerializerBase, value: StateStyles): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_normal  = value.normal
+        let value_normal_type : int32 = RuntimeType.UNDEFINED
+        value_normal_type = runtimeType(value_normal)
+        valueSerializer.writeInt8((value_normal_type).toChar())
+        if ((value_normal_type) != (RuntimeType.UNDEFINED)) {
+            const value_normal_value  = value_normal!
+            valueSerializer.holdAndWriteCallback(value_normal_value)
+        }
+        const value_pressed  = value.pressed
+        let value_pressed_type : int32 = RuntimeType.UNDEFINED
+        value_pressed_type = runtimeType(value_pressed)
+        valueSerializer.writeInt8((value_pressed_type).toChar())
+        if ((value_pressed_type) != (RuntimeType.UNDEFINED)) {
+            const value_pressed_value  = value_pressed!
+            valueSerializer.holdAndWriteCallback(value_pressed_value)
+        }
+        const value_disabled  = value.disabled
+        let value_disabled_type : int32 = RuntimeType.UNDEFINED
+        value_disabled_type = runtimeType(value_disabled)
+        valueSerializer.writeInt8((value_disabled_type).toChar())
+        if ((value_disabled_type) != (RuntimeType.UNDEFINED)) {
+            const value_disabled_value  = value_disabled!
+            valueSerializer.holdAndWriteCallback(value_disabled_value)
+        }
+        const value_focused  = value.focused
+        let value_focused_type : int32 = RuntimeType.UNDEFINED
+        value_focused_type = runtimeType(value_focused)
+        valueSerializer.writeInt8((value_focused_type).toChar())
+        if ((value_focused_type) != (RuntimeType.UNDEFINED)) {
+            const value_focused_value  = value_focused!
+            valueSerializer.holdAndWriteCallback(value_focused_value)
+        }
+        const value_clicked  = value.clicked
+        let value_clicked_type : int32 = RuntimeType.UNDEFINED
+        value_clicked_type = runtimeType(value_clicked)
+        valueSerializer.writeInt8((value_clicked_type).toChar())
+        if ((value_clicked_type) != (RuntimeType.UNDEFINED)) {
+            const value_clicked_value  = value_clicked!
+            valueSerializer.holdAndWriteCallback(value_clicked_value)
+        }
+        const value_selected  = value.selected
+        let value_selected_type : int32 = RuntimeType.UNDEFINED
+        value_selected_type = runtimeType(value_selected)
+        valueSerializer.writeInt8((value_selected_type).toChar())
+        if ((value_selected_type) != (RuntimeType.UNDEFINED)) {
+            const value_selected_value  = value_selected!
+            valueSerializer.holdAndWriteCallback(value_selected_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): StateStyles {
+        let valueDeserializer : DeserializerBase = buffer
+        const normal_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let normal_buf : CustomStyles | undefined
+        if ((normal_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const normal_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const normal_buf__call : KPointer = valueDeserializer.readPointer()
+            const normal_buf__callSync : KPointer = valueDeserializer.readPointer()
+            normal_buf = (instance: string):void => { 
+    const normal_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    normal_buf__argsSerializer.writeInt32(normal_buf__resource.resourceId);
+    normal_buf__argsSerializer.writePointer(normal_buf__call);
+    normal_buf__argsSerializer.writePointer(normal_buf__callSync);
+    normal_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, normal_buf__argsSerializer.asBuffer(), normal_buf__argsSerializer.length());
+    normal_buf__argsSerializer.release();
+    return; }
+        }
+        const normal_result : CustomStyles | undefined = normal_buf
+        const pressed_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let pressed_buf : CustomStyles | undefined
+        if ((pressed_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const pressed_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const pressed_buf__call : KPointer = valueDeserializer.readPointer()
+            const pressed_buf__callSync : KPointer = valueDeserializer.readPointer()
+            pressed_buf = (instance: string):void => { 
+    const pressed_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    pressed_buf__argsSerializer.writeInt32(pressed_buf__resource.resourceId);
+    pressed_buf__argsSerializer.writePointer(pressed_buf__call);
+    pressed_buf__argsSerializer.writePointer(pressed_buf__callSync);
+    pressed_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, pressed_buf__argsSerializer.asBuffer(), pressed_buf__argsSerializer.length());
+    pressed_buf__argsSerializer.release();
+    return; }
+        }
+        const pressed_result : CustomStyles | undefined = pressed_buf
+        const disabled_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let disabled_buf : CustomStyles | undefined
+        if ((disabled_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const disabled_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const disabled_buf__call : KPointer = valueDeserializer.readPointer()
+            const disabled_buf__callSync : KPointer = valueDeserializer.readPointer()
+            disabled_buf = (instance: string):void => { 
+    const disabled_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    disabled_buf__argsSerializer.writeInt32(disabled_buf__resource.resourceId);
+    disabled_buf__argsSerializer.writePointer(disabled_buf__call);
+    disabled_buf__argsSerializer.writePointer(disabled_buf__callSync);
+    disabled_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, disabled_buf__argsSerializer.asBuffer(), disabled_buf__argsSerializer.length());
+    disabled_buf__argsSerializer.release();
+    return; }
+        }
+        const disabled_result : CustomStyles | undefined = disabled_buf
+        const focused_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focused_buf : CustomStyles | undefined
+        if ((focused_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const focused_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const focused_buf__call : KPointer = valueDeserializer.readPointer()
+            const focused_buf__callSync : KPointer = valueDeserializer.readPointer()
+            focused_buf = (instance: string):void => { 
+    const focused_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    focused_buf__argsSerializer.writeInt32(focused_buf__resource.resourceId);
+    focused_buf__argsSerializer.writePointer(focused_buf__call);
+    focused_buf__argsSerializer.writePointer(focused_buf__callSync);
+    focused_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, focused_buf__argsSerializer.asBuffer(), focused_buf__argsSerializer.length());
+    focused_buf__argsSerializer.release();
+    return; }
+        }
+        const focused_result : CustomStyles | undefined = focused_buf
+        const clicked_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let clicked_buf : CustomStyles | undefined
+        if ((clicked_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const clicked_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const clicked_buf__call : KPointer = valueDeserializer.readPointer()
+            const clicked_buf__callSync : KPointer = valueDeserializer.readPointer()
+            clicked_buf = (instance: string):void => { 
+    const clicked_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    clicked_buf__argsSerializer.writeInt32(clicked_buf__resource.resourceId);
+    clicked_buf__argsSerializer.writePointer(clicked_buf__call);
+    clicked_buf__argsSerializer.writePointer(clicked_buf__callSync);
+    clicked_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, clicked_buf__argsSerializer.asBuffer(), clicked_buf__argsSerializer.length());
+    clicked_buf__argsSerializer.release();
+    return; }
+        }
+        const clicked_result : CustomStyles | undefined = clicked_buf
+        const selected_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let selected_buf : CustomStyles | undefined
+        if ((selected_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const selected_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const selected_buf__call : KPointer = valueDeserializer.readPointer()
+            const selected_buf__callSync : KPointer = valueDeserializer.readPointer()
+            selected_buf = (instance: string):void => { 
+    const selected_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    selected_buf__argsSerializer.writeInt32(selected_buf__resource.resourceId);
+    selected_buf__argsSerializer.writePointer(selected_buf__call);
+    selected_buf__argsSerializer.writePointer(selected_buf__callSync);
+    selected_buf__argsSerializer.writeString(instance);
+    InteropNativeModule._CallCallback(-1565709723, selected_buf__argsSerializer.asBuffer(), selected_buf__argsSerializer.length());
+    selected_buf__argsSerializer.release();
+    return; }
+        }
+        const selected_result : CustomStyles | undefined = selected_buf
+        let value : StateStyles = ({normal: normal_result, pressed: pressed_result, disabled: disabled_result, focused: focused_result, clicked: clicked_result, selected: selected_result} as StateStyles)
+        return value
+    }
+}
 export class SystemAdaptiveOptions_serializer {
     public static write(buffer: SerializerBase, value: SystemAdaptiveOptions): void {
         let valueSerializer : SerializerBase = buffer
@@ -16384,242 +16587,526 @@ export class BackgroundEffectOptions_serializer {
         return value
     }
 }
-export class DragPreviewOptions_serializer {
-    public static write(buffer: SerializerBase, value: DragPreviewOptions): void {
+export class ContentCoverOptions_serializer {
+    public static write(buffer: SerializerBase, value: ContentCoverOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_mode  = value.mode
-        let value_mode_type : int32 = RuntimeType.UNDEFINED
-        value_mode_type = runtimeType(value_mode)
-        valueSerializer.writeInt8((value_mode_type).toChar())
-        if ((value_mode_type) != (RuntimeType.UNDEFINED)) {
-            const value_mode_value  = value_mode!
-            let value_mode_value_type : int32 = RuntimeType.UNDEFINED
-            value_mode_value_type = runtimeType(value_mode_value)
-            if (TypeChecker.isDragPreviewMode(value_mode_value)) {
+        const value_backgroundColor  = value.backgroundColor
+        let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundColor_type = runtimeType(value_backgroundColor)
+        valueSerializer.writeInt8((value_backgroundColor_type).toChar())
+        if ((value_backgroundColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundColor_value  = value_backgroundColor!
+            let value_backgroundColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_backgroundColor_value_type = runtimeType(value_backgroundColor_value)
+            if (TypeChecker.isColor(value_backgroundColor_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_mode_value_0  = value_mode_value as DragPreviewMode
-                valueSerializer.writeInt32(TypeChecker.DragPreviewMode_ToNumeric(value_mode_value_0))
+                const value_backgroundColor_value_0  = value_backgroundColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_backgroundColor_value_0))
             }
-            else if (RuntimeType.OBJECT == value_mode_value_type) {
+            else if (RuntimeType.NUMBER == value_backgroundColor_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_mode_value_1  = value_mode_value as Array<DragPreviewMode>
-                valueSerializer.writeInt32((value_mode_value_1.length).toInt())
-                for (let value_mode_value_1_counter_i = 0; value_mode_value_1_counter_i < value_mode_value_1.length; value_mode_value_1_counter_i++) {
-                    const value_mode_value_1_element : DragPreviewMode = value_mode_value_1[value_mode_value_1_counter_i]
-                    valueSerializer.writeInt32(TypeChecker.DragPreviewMode_ToNumeric(value_mode_value_1_element))
-                }
+                const value_backgroundColor_value_1  = value_backgroundColor_value as number
+                valueSerializer.writeNumber(value_backgroundColor_value_1)
             }
-        }
-        const value_numberBadge  = value.numberBadge
-        let value_numberBadge_type : int32 = RuntimeType.UNDEFINED
-        value_numberBadge_type = runtimeType(value_numberBadge)
-        valueSerializer.writeInt8((value_numberBadge_type).toChar())
-        if ((value_numberBadge_type) != (RuntimeType.UNDEFINED)) {
-            const value_numberBadge_value  = value_numberBadge!
-            let value_numberBadge_value_type : int32 = RuntimeType.UNDEFINED
-            value_numberBadge_value_type = runtimeType(value_numberBadge_value)
-            if (RuntimeType.BOOLEAN == value_numberBadge_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_numberBadge_value_0  = value_numberBadge_value as boolean
-                valueSerializer.writeBoolean(value_numberBadge_value_0)
+            else if (RuntimeType.STRING == value_backgroundColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_backgroundColor_value_2  = value_backgroundColor_value as string
+                valueSerializer.writeString(value_backgroundColor_value_2)
             }
-            else if (RuntimeType.NUMBER == value_numberBadge_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_numberBadge_value_1  = value_numberBadge_value as number
-                valueSerializer.writeNumber(value_numberBadge_value_1)
+            else if (RuntimeType.OBJECT == value_backgroundColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_backgroundColor_value_3  = value_backgroundColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
             }
         }
-        const value_sizeChangeEffect  = value.sizeChangeEffect
-        let value_sizeChangeEffect_type : int32 = RuntimeType.UNDEFINED
-        value_sizeChangeEffect_type = runtimeType(value_sizeChangeEffect)
-        valueSerializer.writeInt8((value_sizeChangeEffect_type).toChar())
-        if ((value_sizeChangeEffect_type) != (RuntimeType.UNDEFINED)) {
-            const value_sizeChangeEffect_value  = (value_sizeChangeEffect as DraggingSizeChangeEffect)
-            valueSerializer.writeInt32(TypeChecker.DraggingSizeChangeEffect_ToNumeric(value_sizeChangeEffect_value))
+        const value_onAppear  = value.onAppear
+        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onAppear_type = runtimeType(value_onAppear)
+        valueSerializer.writeInt8((value_onAppear_type).toChar())
+        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onAppear_value  = value_onAppear!
+            valueSerializer.holdAndWriteCallback(value_onAppear_value)
+        }
+        const value_onDisappear  = value.onDisappear
+        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onDisappear_type = runtimeType(value_onDisappear)
+        valueSerializer.writeInt8((value_onDisappear_type).toChar())
+        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onDisappear_value  = value_onDisappear!
+            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
+        }
+        const value_onWillAppear  = value.onWillAppear
+        let value_onWillAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onWillAppear_type = runtimeType(value_onWillAppear)
+        valueSerializer.writeInt8((value_onWillAppear_type).toChar())
+        if ((value_onWillAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillAppear_value  = value_onWillAppear!
+            valueSerializer.holdAndWriteCallback(value_onWillAppear_value)
+        }
+        const value_onWillDisappear  = value.onWillDisappear
+        let value_onWillDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onWillDisappear_type = runtimeType(value_onWillDisappear)
+        valueSerializer.writeInt8((value_onWillDisappear_type).toChar())
+        if ((value_onWillDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillDisappear_value  = value_onWillDisappear!
+            valueSerializer.holdAndWriteCallback(value_onWillDisappear_value)
+        }
+        const value_modalTransition  = value.modalTransition
+        let value_modalTransition_type : int32 = RuntimeType.UNDEFINED
+        value_modalTransition_type = runtimeType(value_modalTransition)
+        valueSerializer.writeInt8((value_modalTransition_type).toChar())
+        if ((value_modalTransition_type) != (RuntimeType.UNDEFINED)) {
+            const value_modalTransition_value  = (value_modalTransition as ModalTransition)
+            valueSerializer.writeInt32(TypeChecker.ModalTransition_ToNumeric(value_modalTransition_value))
+        }
+        const value_onWillDismiss  = value.onWillDismiss
+        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
+        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
+        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
+        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillDismiss_value  = value_onWillDismiss!
+            valueSerializer.holdAndWriteCallback(value_onWillDismiss_value)
+        }
+        const value_transition  = value.transition
+        let value_transition_type : int32 = RuntimeType.UNDEFINED
+        value_transition_type = runtimeType(value_transition)
+        valueSerializer.writeInt8((value_transition_type).toChar())
+        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
+            const value_transition_value  = value_transition!
+            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
         }
     }
-    public static read(buffer: DeserializerBase): DragPreviewOptions {
+    public static read(buffer: DeserializerBase): ContentCoverOptions {
         let valueDeserializer : DeserializerBase = buffer
-        const mode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let mode_buf : DragPreviewMode | Array<DragPreviewMode> | undefined
-        if ((mode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundColor_buf : ResourceColor | undefined
+        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const mode_buf__selector : int32 = valueDeserializer.readInt8()
-            let mode_buf_ : DragPreviewMode | Array<DragPreviewMode> | undefined
-            if (mode_buf__selector == (0).toChar()) {
-                mode_buf_ = TypeChecker.DragPreviewMode_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (mode_buf__selector == (1).toChar()) {
-                const mode_buf__u_length : int32 = valueDeserializer.readInt32()
-                let mode_buf__u : Array<DragPreviewMode> = new Array<DragPreviewMode>(mode_buf__u_length)
-                for (let mode_buf__u_i = 0; mode_buf__u_i < mode_buf__u_length; mode_buf__u_i++) {
-                    mode_buf__u[mode_buf__u_i] = TypeChecker.DragPreviewMode_FromNumeric(valueDeserializer.readInt32())
-                }
-                mode_buf_ = mode_buf__u
+            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let backgroundColor_buf_ : Color | number | string | Resource | undefined
+            if (backgroundColor_buf__selector == (0).toChar()) {
+                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else {
-                throw new Error("One of the branches for mode_buf_ has to be chosen through deserialisation.")
+            else if (backgroundColor_buf__selector == (1).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-            mode_buf = (mode_buf_ as DragPreviewMode | Array<DragPreviewMode>)
-        }
-        const mode_result : DragPreviewMode | Array<DragPreviewMode> | undefined = mode_buf
-        const numberBadge_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let numberBadge_buf : boolean | number | undefined
-        if ((numberBadge_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const numberBadge_buf__selector : int32 = valueDeserializer.readInt8()
-            let numberBadge_buf_ : boolean | number | undefined
-            if (numberBadge_buf__selector == (0).toChar()) {
-                numberBadge_buf_ = valueDeserializer.readBoolean()
+            else if (backgroundColor_buf__selector == (2).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (numberBadge_buf__selector == (1).toChar()) {
-                numberBadge_buf_ = (valueDeserializer.readNumber() as number)
+            else if (backgroundColor_buf__selector == (3).toChar()) {
+                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for numberBadge_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
             }
-            numberBadge_buf = (numberBadge_buf_ as boolean | number)
+            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
         }
-        const numberBadge_result : boolean | number | undefined = numberBadge_buf
-        const sizeChangeEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let sizeChangeEffect_buf : DraggingSizeChangeEffect | undefined
-        if ((sizeChangeEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onAppear_buf : (() => void) | undefined
+        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            sizeChangeEffect_buf = TypeChecker.DraggingSizeChangeEffect_FromNumeric(valueDeserializer.readInt32())
+            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onAppear_buf = ():void => { 
+    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
+    onAppear_buf__argsSerializer.release();
+    return; }
         }
-        const sizeChangeEffect_result : DraggingSizeChangeEffect | undefined = sizeChangeEffect_buf
-        let value : DragPreviewOptions = ({mode: mode_result, numberBadge: numberBadge_result, sizeChangeEffect: sizeChangeEffect_result} as DragPreviewOptions)
-        return value
-    }
-}
-export class FadingEdgeOptions_serializer {
-    public static write(buffer: SerializerBase, value: FadingEdgeOptions): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_fadingEdgeLength  = value.fadingEdgeLength
-        let value_fadingEdgeLength_type : int32 = RuntimeType.UNDEFINED
-        value_fadingEdgeLength_type = runtimeType(value_fadingEdgeLength)
-        valueSerializer.writeInt8((value_fadingEdgeLength_type).toChar())
-        if ((value_fadingEdgeLength_type) != (RuntimeType.UNDEFINED)) {
-            const value_fadingEdgeLength_value  = value_fadingEdgeLength!
-            LengthMetrics_serializer.write(valueSerializer, value_fadingEdgeLength_value)
+        const onAppear_result : (() => void) | undefined = onAppear_buf
+        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onDisappear_buf : (() => void) | undefined
+        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onDisappear_buf = ():void => { 
+    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
+    onDisappear_buf__argsSerializer.release();
+    return; }
         }
-    }
-    public static read(buffer: DeserializerBase): FadingEdgeOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const fadingEdgeLength_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fadingEdgeLength_buf : LengthMetrics | undefined
-        if ((fadingEdgeLength_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const onDisappear_result : (() => void) | undefined = onDisappear_buf
+        const onWillAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillAppear_buf : (() => void) | undefined
+        if ((onWillAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            fadingEdgeLength_buf = (LengthMetrics_serializer.read(valueDeserializer) as LengthMetrics)
+            const onWillAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillAppear_buf = ():void => { 
+    const onWillAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillAppear_buf__argsSerializer.writeInt32(onWillAppear_buf__resource.resourceId);
+    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__call);
+    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onWillAppear_buf__argsSerializer.asBuffer(), onWillAppear_buf__argsSerializer.length());
+    onWillAppear_buf__argsSerializer.release();
+    return; }
         }
-        const fadingEdgeLength_result : LengthMetrics | undefined = fadingEdgeLength_buf
-        let value : FadingEdgeOptions = ({fadingEdgeLength: fadingEdgeLength_result} as FadingEdgeOptions)
+        const onWillAppear_result : (() => void) | undefined = onWillAppear_buf
+        const onWillDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillDisappear_buf : (() => void) | undefined
+        if ((onWillDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onWillDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillDisappear_buf = ():void => { 
+    const onWillDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillDisappear_buf__argsSerializer.writeInt32(onWillDisappear_buf__resource.resourceId);
+    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__call);
+    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onWillDisappear_buf__argsSerializer.asBuffer(), onWillDisappear_buf__argsSerializer.length());
+    onWillDisappear_buf__argsSerializer.release();
+    return; }
+        }
+        const onWillDisappear_result : (() => void) | undefined = onWillDisappear_buf
+        const modalTransition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let modalTransition_buf : ModalTransition | undefined
+        if ((modalTransition_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            modalTransition_buf = TypeChecker.ModalTransition_FromNumeric(valueDeserializer.readInt32())
+        }
+        const modalTransition_result : ModalTransition | undefined = modalTransition_buf
+        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillDismiss_buf : ((value0: DismissContentCoverAction) => void) | undefined
+        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onWillDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillDismiss_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillDismiss_buf = (value0: DismissContentCoverAction):void => { 
+    const onWillDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillDismiss_buf__argsSerializer.writeInt32(onWillDismiss_buf__resource.resourceId);
+    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__call);
+    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__callSync);
+    DismissContentCoverAction_serializer.write(onWillDismiss_buf__argsSerializer, value0);
+    InteropNativeModule._CallCallback(-1283506641, onWillDismiss_buf__argsSerializer.asBuffer(), onWillDismiss_buf__argsSerializer.length());
+    onWillDismiss_buf__argsSerializer.release();
+    return; }
+        }
+        const onWillDismiss_result : ((value0: DismissContentCoverAction) => void) | undefined = onWillDismiss_buf
+        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let transition_buf : TransitionEffect | undefined
+        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+        }
+        const transition_result : TransitionEffect | undefined = transition_buf
+        let value : ContentCoverOptions = ({backgroundColor: backgroundColor_result, onAppear: onAppear_result, onDisappear: onDisappear_result, onWillAppear: onWillAppear_result, onWillDisappear: onWillDisappear_result, modalTransition: modalTransition_result, onWillDismiss: onWillDismiss_result, transition: transition_result} as ContentCoverOptions)
         return value
     }
 }
-export class ForegroundBlurStyleOptions_serializer {
-    public static write(buffer: SerializerBase, value: ForegroundBlurStyleOptions): void {
+export class ContextMenuAnimationOptions_serializer {
+    public static write(buffer: SerializerBase, value: ContextMenuAnimationOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_colorMode  = value.colorMode
-        let value_colorMode_type : int32 = RuntimeType.UNDEFINED
-        value_colorMode_type = runtimeType(value_colorMode)
-        valueSerializer.writeInt8((value_colorMode_type).toChar())
-        if ((value_colorMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_colorMode_value  = (value_colorMode as ThemeColorMode)
-            valueSerializer.writeInt32(TypeChecker.ThemeColorMode_ToNumeric(value_colorMode_value))
-        }
-        const value_adaptiveColor  = value.adaptiveColor
-        let value_adaptiveColor_type : int32 = RuntimeType.UNDEFINED
-        value_adaptiveColor_type = runtimeType(value_adaptiveColor)
-        valueSerializer.writeInt8((value_adaptiveColor_type).toChar())
-        if ((value_adaptiveColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_adaptiveColor_value  = (value_adaptiveColor as AdaptiveColor)
-            valueSerializer.writeInt32(TypeChecker.AdaptiveColor_ToNumeric(value_adaptiveColor_value))
-        }
         const value_scale  = value.scale
         let value_scale_type : int32 = RuntimeType.UNDEFINED
         value_scale_type = runtimeType(value_scale)
         valueSerializer.writeInt8((value_scale_type).toChar())
         if ((value_scale_type) != (RuntimeType.UNDEFINED)) {
             const value_scale_value  = value_scale!
-            valueSerializer.writeNumber(value_scale_value)
+            const value_scale_value_0  = value_scale_value[0]
+            valueSerializer.writeNumber(value_scale_value_0)
+            const value_scale_value_1  = value_scale_value[1]
+            valueSerializer.writeNumber(value_scale_value_1)
         }
-        const value_blurOptions  = value.blurOptions
-        let value_blurOptions_type : int32 = RuntimeType.UNDEFINED
-        value_blurOptions_type = runtimeType(value_blurOptions)
-        valueSerializer.writeInt8((value_blurOptions_type).toChar())
-        if ((value_blurOptions_type) != (RuntimeType.UNDEFINED)) {
-            const value_blurOptions_value  = value_blurOptions!
-            BlurOptions_serializer.write(valueSerializer, value_blurOptions_value)
+        const value_transition  = value.transition
+        let value_transition_type : int32 = RuntimeType.UNDEFINED
+        value_transition_type = runtimeType(value_transition)
+        valueSerializer.writeInt8((value_transition_type).toChar())
+        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
+            const value_transition_value  = value_transition!
+            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
+        }
+        const value_hoverScale  = value.hoverScale
+        let value_hoverScale_type : int32 = RuntimeType.UNDEFINED
+        value_hoverScale_type = runtimeType(value_hoverScale)
+        valueSerializer.writeInt8((value_hoverScale_type).toChar())
+        if ((value_hoverScale_type) != (RuntimeType.UNDEFINED)) {
+            const value_hoverScale_value  = value_hoverScale!
+            const value_hoverScale_value_0  = value_hoverScale_value[0]
+            valueSerializer.writeNumber(value_hoverScale_value_0)
+            const value_hoverScale_value_1  = value_hoverScale_value[1]
+            valueSerializer.writeNumber(value_hoverScale_value_1)
         }
     }
-    public static read(buffer: DeserializerBase): ForegroundBlurStyleOptions {
+    public static read(buffer: DeserializerBase): ContextMenuAnimationOptions {
         let valueDeserializer : DeserializerBase = buffer
-        const colorMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let colorMode_buf : ThemeColorMode | undefined
-        if ((colorMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            colorMode_buf = TypeChecker.ThemeColorMode_FromNumeric(valueDeserializer.readInt32())
-        }
-        const colorMode_result : ThemeColorMode | undefined = colorMode_buf
-        const adaptiveColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let adaptiveColor_buf : AdaptiveColor | undefined
-        if ((adaptiveColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            adaptiveColor_buf = TypeChecker.AdaptiveColor_FromNumeric(valueDeserializer.readInt32())
-        }
-        const adaptiveColor_result : AdaptiveColor | undefined = adaptiveColor_buf
         const scale_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let scale_buf : number | undefined
+        let scale_buf : AnimationNumberRange | undefined
         if ((scale_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            scale_buf = (valueDeserializer.readNumber() as number)
+            const scale_buf__value0 : number = (valueDeserializer.readNumber() as number)
+            const scale_buf__value1 : number = (valueDeserializer.readNumber() as number)
+            scale_buf = ([scale_buf__value0, scale_buf__value1] as AnimationNumberRange)
         }
-        const scale_result : number | undefined = scale_buf
-        const blurOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let blurOptions_buf : BlurOptions | undefined
-        if ((blurOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const scale_result : AnimationNumberRange | undefined = scale_buf
+        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let transition_buf : TransitionEffect | undefined
+        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            blurOptions_buf = BlurOptions_serializer.read(valueDeserializer)
+            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
         }
-        const blurOptions_result : BlurOptions | undefined = blurOptions_buf
-        let value : ForegroundBlurStyleOptions = ({colorMode: colorMode_result, adaptiveColor: adaptiveColor_result, scale: scale_result, blurOptions: blurOptions_result} as ForegroundBlurStyleOptions)
-        return value
-    }
-}
-export class HistoricalPoint_serializer {
-    public static write(buffer: SerializerBase, value: HistoricalPoint): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_touchObject  = value.touchObject
-        TouchObject_serializer.write(valueSerializer, value_touchObject)
-        const value_size  = value.size
-        valueSerializer.writeNumber(value_size)
-        const value_force  = value.force
-        valueSerializer.writeNumber(value_force)
-        const value_timestamp  = value.timestamp
-        valueSerializer.writeNumber(value_timestamp)
-    }
-    public static read(buffer: DeserializerBase): HistoricalPoint {
-        let valueDeserializer : DeserializerBase = buffer
-        const touchObject_result : TouchObject = TouchObject_serializer.read(valueDeserializer)
-        const size_result : number = (valueDeserializer.readNumber() as number)
-        const force_result : number = (valueDeserializer.readNumber() as number)
-        const timestamp_result : number = (valueDeserializer.readNumber() as number)
-        let value : HistoricalPoint = ({touchObject: touchObject_result, size: size_result, force: force_result, timestamp: timestamp_result} as HistoricalPoint)
+        const transition_result : TransitionEffect | undefined = transition_buf
+        const hoverScale_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let hoverScale_buf : AnimationNumberRange | undefined
+        if ((hoverScale_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const hoverScale_buf__value0 : number = (valueDeserializer.readNumber() as number)
+            const hoverScale_buf__value1 : number = (valueDeserializer.readNumber() as number)
+            hoverScale_buf = ([hoverScale_buf__value0, hoverScale_buf__value1] as AnimationNumberRange)
+        }
+        const hoverScale_result : AnimationNumberRange | undefined = hoverScale_buf
+        let value : ContextMenuAnimationOptions = ({scale: scale_result, transition: transition_result, hoverScale: hoverScale_result} as ContextMenuAnimationOptions)
         return value
     }
 }
-export class Layoutable_serializer {
-    public static write(buffer: SerializerBase, value: Layoutable): void {
+export class DragPreviewOptions_serializer {
+    public static write(buffer: SerializerBase, value: DragPreviewOptions): void {
         let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): Layoutable {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return LayoutableInternal.fromPtr(ptr)
-    }
-}
+        const value_mode  = value.mode
+        let value_mode_type : int32 = RuntimeType.UNDEFINED
+        value_mode_type = runtimeType(value_mode)
+        valueSerializer.writeInt8((value_mode_type).toChar())
+        if ((value_mode_type) != (RuntimeType.UNDEFINED)) {
+            const value_mode_value  = value_mode!
+            let value_mode_value_type : int32 = RuntimeType.UNDEFINED
+            value_mode_value_type = runtimeType(value_mode_value)
+            if (TypeChecker.isDragPreviewMode(value_mode_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_mode_value_0  = value_mode_value as DragPreviewMode
+                valueSerializer.writeInt32(TypeChecker.DragPreviewMode_ToNumeric(value_mode_value_0))
+            }
+            else if (RuntimeType.OBJECT == value_mode_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_mode_value_1  = value_mode_value as Array<DragPreviewMode>
+                valueSerializer.writeInt32((value_mode_value_1.length).toInt())
+                for (let value_mode_value_1_counter_i = 0; value_mode_value_1_counter_i < value_mode_value_1.length; value_mode_value_1_counter_i++) {
+                    const value_mode_value_1_element : DragPreviewMode = value_mode_value_1[value_mode_value_1_counter_i]
+                    valueSerializer.writeInt32(TypeChecker.DragPreviewMode_ToNumeric(value_mode_value_1_element))
+                }
+            }
+        }
+        const value_numberBadge  = value.numberBadge
+        let value_numberBadge_type : int32 = RuntimeType.UNDEFINED
+        value_numberBadge_type = runtimeType(value_numberBadge)
+        valueSerializer.writeInt8((value_numberBadge_type).toChar())
+        if ((value_numberBadge_type) != (RuntimeType.UNDEFINED)) {
+            const value_numberBadge_value  = value_numberBadge!
+            let value_numberBadge_value_type : int32 = RuntimeType.UNDEFINED
+            value_numberBadge_value_type = runtimeType(value_numberBadge_value)
+            if (RuntimeType.BOOLEAN == value_numberBadge_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_numberBadge_value_0  = value_numberBadge_value as boolean
+                valueSerializer.writeBoolean(value_numberBadge_value_0)
+            }
+            else if (RuntimeType.NUMBER == value_numberBadge_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_numberBadge_value_1  = value_numberBadge_value as number
+                valueSerializer.writeNumber(value_numberBadge_value_1)
+            }
+        }
+        const value_sizeChangeEffect  = value.sizeChangeEffect
+        let value_sizeChangeEffect_type : int32 = RuntimeType.UNDEFINED
+        value_sizeChangeEffect_type = runtimeType(value_sizeChangeEffect)
+        valueSerializer.writeInt8((value_sizeChangeEffect_type).toChar())
+        if ((value_sizeChangeEffect_type) != (RuntimeType.UNDEFINED)) {
+            const value_sizeChangeEffect_value  = (value_sizeChangeEffect as DraggingSizeChangeEffect)
+            valueSerializer.writeInt32(TypeChecker.DraggingSizeChangeEffect_ToNumeric(value_sizeChangeEffect_value))
+        }
+    }
+    public static read(buffer: DeserializerBase): DragPreviewOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const mode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let mode_buf : DragPreviewMode | Array<DragPreviewMode> | undefined
+        if ((mode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const mode_buf__selector : int32 = valueDeserializer.readInt8()
+            let mode_buf_ : DragPreviewMode | Array<DragPreviewMode> | undefined
+            if (mode_buf__selector == (0).toChar()) {
+                mode_buf_ = TypeChecker.DragPreviewMode_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (mode_buf__selector == (1).toChar()) {
+                const mode_buf__u_length : int32 = valueDeserializer.readInt32()
+                let mode_buf__u : Array<DragPreviewMode> = new Array<DragPreviewMode>(mode_buf__u_length)
+                for (let mode_buf__u_i = 0; mode_buf__u_i < mode_buf__u_length; mode_buf__u_i++) {
+                    mode_buf__u[mode_buf__u_i] = TypeChecker.DragPreviewMode_FromNumeric(valueDeserializer.readInt32())
+                }
+                mode_buf_ = mode_buf__u
+            }
+            else {
+                throw new Error("One of the branches for mode_buf_ has to be chosen through deserialisation.")
+            }
+            mode_buf = (mode_buf_ as DragPreviewMode | Array<DragPreviewMode>)
+        }
+        const mode_result : DragPreviewMode | Array<DragPreviewMode> | undefined = mode_buf
+        const numberBadge_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let numberBadge_buf : boolean | number | undefined
+        if ((numberBadge_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const numberBadge_buf__selector : int32 = valueDeserializer.readInt8()
+            let numberBadge_buf_ : boolean | number | undefined
+            if (numberBadge_buf__selector == (0).toChar()) {
+                numberBadge_buf_ = valueDeserializer.readBoolean()
+            }
+            else if (numberBadge_buf__selector == (1).toChar()) {
+                numberBadge_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else {
+                throw new Error("One of the branches for numberBadge_buf_ has to be chosen through deserialisation.")
+            }
+            numberBadge_buf = (numberBadge_buf_ as boolean | number)
+        }
+        const numberBadge_result : boolean | number | undefined = numberBadge_buf
+        const sizeChangeEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let sizeChangeEffect_buf : DraggingSizeChangeEffect | undefined
+        if ((sizeChangeEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            sizeChangeEffect_buf = TypeChecker.DraggingSizeChangeEffect_FromNumeric(valueDeserializer.readInt32())
+        }
+        const sizeChangeEffect_result : DraggingSizeChangeEffect | undefined = sizeChangeEffect_buf
+        let value : DragPreviewOptions = ({mode: mode_result, numberBadge: numberBadge_result, sizeChangeEffect: sizeChangeEffect_result} as DragPreviewOptions)
+        return value
+    }
+}
+export class FadingEdgeOptions_serializer {
+    public static write(buffer: SerializerBase, value: FadingEdgeOptions): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_fadingEdgeLength  = value.fadingEdgeLength
+        let value_fadingEdgeLength_type : int32 = RuntimeType.UNDEFINED
+        value_fadingEdgeLength_type = runtimeType(value_fadingEdgeLength)
+        valueSerializer.writeInt8((value_fadingEdgeLength_type).toChar())
+        if ((value_fadingEdgeLength_type) != (RuntimeType.UNDEFINED)) {
+            const value_fadingEdgeLength_value  = value_fadingEdgeLength!
+            LengthMetrics_serializer.write(valueSerializer, value_fadingEdgeLength_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): FadingEdgeOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const fadingEdgeLength_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fadingEdgeLength_buf : LengthMetrics | undefined
+        if ((fadingEdgeLength_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            fadingEdgeLength_buf = (LengthMetrics_serializer.read(valueDeserializer) as LengthMetrics)
+        }
+        const fadingEdgeLength_result : LengthMetrics | undefined = fadingEdgeLength_buf
+        let value : FadingEdgeOptions = ({fadingEdgeLength: fadingEdgeLength_result} as FadingEdgeOptions)
+        return value
+    }
+}
+export class ForegroundBlurStyleOptions_serializer {
+    public static write(buffer: SerializerBase, value: ForegroundBlurStyleOptions): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_colorMode  = value.colorMode
+        let value_colorMode_type : int32 = RuntimeType.UNDEFINED
+        value_colorMode_type = runtimeType(value_colorMode)
+        valueSerializer.writeInt8((value_colorMode_type).toChar())
+        if ((value_colorMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_colorMode_value  = (value_colorMode as ThemeColorMode)
+            valueSerializer.writeInt32(TypeChecker.ThemeColorMode_ToNumeric(value_colorMode_value))
+        }
+        const value_adaptiveColor  = value.adaptiveColor
+        let value_adaptiveColor_type : int32 = RuntimeType.UNDEFINED
+        value_adaptiveColor_type = runtimeType(value_adaptiveColor)
+        valueSerializer.writeInt8((value_adaptiveColor_type).toChar())
+        if ((value_adaptiveColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_adaptiveColor_value  = (value_adaptiveColor as AdaptiveColor)
+            valueSerializer.writeInt32(TypeChecker.AdaptiveColor_ToNumeric(value_adaptiveColor_value))
+        }
+        const value_scale  = value.scale
+        let value_scale_type : int32 = RuntimeType.UNDEFINED
+        value_scale_type = runtimeType(value_scale)
+        valueSerializer.writeInt8((value_scale_type).toChar())
+        if ((value_scale_type) != (RuntimeType.UNDEFINED)) {
+            const value_scale_value  = value_scale!
+            valueSerializer.writeNumber(value_scale_value)
+        }
+        const value_blurOptions  = value.blurOptions
+        let value_blurOptions_type : int32 = RuntimeType.UNDEFINED
+        value_blurOptions_type = runtimeType(value_blurOptions)
+        valueSerializer.writeInt8((value_blurOptions_type).toChar())
+        if ((value_blurOptions_type) != (RuntimeType.UNDEFINED)) {
+            const value_blurOptions_value  = value_blurOptions!
+            BlurOptions_serializer.write(valueSerializer, value_blurOptions_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): ForegroundBlurStyleOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const colorMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let colorMode_buf : ThemeColorMode | undefined
+        if ((colorMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            colorMode_buf = TypeChecker.ThemeColorMode_FromNumeric(valueDeserializer.readInt32())
+        }
+        const colorMode_result : ThemeColorMode | undefined = colorMode_buf
+        const adaptiveColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let adaptiveColor_buf : AdaptiveColor | undefined
+        if ((adaptiveColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            adaptiveColor_buf = TypeChecker.AdaptiveColor_FromNumeric(valueDeserializer.readInt32())
+        }
+        const adaptiveColor_result : AdaptiveColor | undefined = adaptiveColor_buf
+        const scale_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let scale_buf : number | undefined
+        if ((scale_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            scale_buf = (valueDeserializer.readNumber() as number)
+        }
+        const scale_result : number | undefined = scale_buf
+        const blurOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let blurOptions_buf : BlurOptions | undefined
+        if ((blurOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            blurOptions_buf = BlurOptions_serializer.read(valueDeserializer)
+        }
+        const blurOptions_result : BlurOptions | undefined = blurOptions_buf
+        let value : ForegroundBlurStyleOptions = ({colorMode: colorMode_result, adaptiveColor: adaptiveColor_result, scale: scale_result, blurOptions: blurOptions_result} as ForegroundBlurStyleOptions)
+        return value
+    }
+}
+export class HistoricalPoint_serializer {
+    public static write(buffer: SerializerBase, value: HistoricalPoint): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_touchObject  = value.touchObject
+        TouchObject_serializer.write(valueSerializer, value_touchObject)
+        const value_size  = value.size
+        valueSerializer.writeNumber(value_size)
+        const value_force  = value.force
+        valueSerializer.writeNumber(value_force)
+        const value_timestamp  = value.timestamp
+        valueSerializer.writeNumber(value_timestamp)
+    }
+    public static read(buffer: DeserializerBase): HistoricalPoint {
+        let valueDeserializer : DeserializerBase = buffer
+        const touchObject_result : TouchObject = TouchObject_serializer.read(valueDeserializer)
+        const size_result : number = (valueDeserializer.readNumber() as number)
+        const force_result : number = (valueDeserializer.readNumber() as number)
+        const timestamp_result : number = (valueDeserializer.readNumber() as number)
+        let value : HistoricalPoint = ({touchObject: touchObject_result, size: size_result, force: force_result, timestamp: timestamp_result} as HistoricalPoint)
+        return value
+    }
+}
+export class Layoutable_serializer {
+    public static write(buffer: SerializerBase, value: Layoutable): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): Layoutable {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return LayoutableInternal.fromPtr(ptr)
+    }
+}
 export class LightSource_serializer {
     public static write(buffer: SerializerBase, value: LightSource): void {
         let valueSerializer : SerializerBase = buffer
@@ -19208,234 +19695,204 @@ export class BorderImageOption_serializer {
         return value
     }
 }
-export class EventTarget_serializer {
-    public static write(buffer: SerializerBase, value: EventTarget): void {
+export class ContextMenuOptions_serializer {
+    public static write(buffer: SerializerBase, value: ContextMenuOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_area  = value.area
-        Area_serializer.write(valueSerializer, value_area)
-        const value_id  = value.id
-        let value_id_type : int32 = RuntimeType.UNDEFINED
-        value_id_type = runtimeType(value_id)
-        valueSerializer.writeInt8((value_id_type).toChar())
-        if ((value_id_type) != (RuntimeType.UNDEFINED)) {
-            const value_id_value  = value_id!
-            valueSerializer.writeString(value_id_value)
+        const value_offset  = value.offset
+        let value_offset_type : int32 = RuntimeType.UNDEFINED
+        value_offset_type = runtimeType(value_offset)
+        valueSerializer.writeInt8((value_offset_type).toChar())
+        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
+            const value_offset_value  = value_offset!
+            Position_serializer.write(valueSerializer, value_offset_value)
         }
-    }
-    public static read(buffer: DeserializerBase): EventTarget {
-        let valueDeserializer : DeserializerBase = buffer
-        const area_result : Area = Area_serializer.read(valueDeserializer)
-        const id_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let id_buf : string | undefined
-        if ((id_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            id_buf = (valueDeserializer.readString() as string)
-        }
-        const id_result : string | undefined = id_buf
-        let value : EventTarget = ({area: area_result, id: id_result} as EventTarget)
-        return value
-    }
-}
-export class FocusAxisEvent_serializer {
-    public static write(buffer: SerializerBase, value: FocusAxisEvent): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): FocusAxisEvent {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return FocusAxisEventInternal.fromPtr(ptr)
-    }
-}
-export class GeometryInfo_serializer {
-    public static write(buffer: SerializerBase, value: GeometryInfo): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_width  = value.width
-        valueSerializer.writeNumber(value_width)
-        const value_height  = value.height
-        valueSerializer.writeNumber(value_height)
-        const value_borderWidth  = value.borderWidth
-        EdgeWidths_serializer.write(valueSerializer, value_borderWidth)
-        const value_margin  = value.margin
-        Padding_serializer.write(valueSerializer, value_margin)
-        const value_padding  = value.padding
-        Padding_serializer.write(valueSerializer, value_padding)
-    }
-    public static read(buffer: DeserializerBase): GeometryInfo {
-        let valueDeserializer : DeserializerBase = buffer
-        const width_result : number = (valueDeserializer.readNumber() as number)
-        const height_result : number = (valueDeserializer.readNumber() as number)
-        const borderWidth_result : EdgeWidths = EdgeWidths_serializer.read(valueDeserializer)
-        const margin_result : Padding = Padding_serializer.read(valueDeserializer)
-        const padding_result : Padding = Padding_serializer.read(valueDeserializer)
-        let value : GeometryInfo = ({width: width_result, height: height_result, borderWidth: borderWidth_result, margin: margin_result, padding: padding_result} as GeometryInfo)
-        return value
-    }
-}
-export class HoverEvent_serializer {
-    public static write(buffer: SerializerBase, value: HoverEvent): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): HoverEvent {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return HoverEventInternal.fromPtr(ptr)
-    }
-}
-export class LayoutChild_serializer {
-    public static write(buffer: SerializerBase, value: LayoutChild): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): LayoutChild {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return LayoutChildInternal.fromPtr(ptr)
-    }
-}
-export class MouseEvent_serializer {
-    public static write(buffer: SerializerBase, value: MouseEvent): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): MouseEvent {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return MouseEventInternal.fromPtr(ptr)
-    }
-}
-export class PickerDialogButtonStyle_serializer {
-    public static write(buffer: SerializerBase, value: PickerDialogButtonStyle): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_type  = value.type
-        let value_type_type : int32 = RuntimeType.UNDEFINED
-        value_type_type = runtimeType(value_type)
-        valueSerializer.writeInt8((value_type_type).toChar())
-        if ((value_type_type) != (RuntimeType.UNDEFINED)) {
-            const value_type_value  = (value_type as ButtonType)
-            valueSerializer.writeInt32(TypeChecker.ButtonType_ToNumeric(value_type_value))
-        }
-        const value_style  = value.style
-        let value_style_type : int32 = RuntimeType.UNDEFINED
-        value_style_type = runtimeType(value_style)
-        valueSerializer.writeInt8((value_style_type).toChar())
-        if ((value_style_type) != (RuntimeType.UNDEFINED)) {
-            const value_style_value  = (value_style as ButtonStyleMode)
-            valueSerializer.writeInt32(TypeChecker.ButtonStyleMode_ToNumeric(value_style_value))
+        const value_placement  = value.placement
+        let value_placement_type : int32 = RuntimeType.UNDEFINED
+        value_placement_type = runtimeType(value_placement)
+        valueSerializer.writeInt8((value_placement_type).toChar())
+        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
+            const value_placement_value  = (value_placement as Placement)
+            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
         }
-        const value_role  = value.role
-        let value_role_type : int32 = RuntimeType.UNDEFINED
-        value_role_type = runtimeType(value_role)
-        valueSerializer.writeInt8((value_role_type).toChar())
-        if ((value_role_type) != (RuntimeType.UNDEFINED)) {
-            const value_role_value  = (value_role as ButtonRole)
-            valueSerializer.writeInt32(TypeChecker.ButtonRole_ToNumeric(value_role_value))
+        const value_enableArrow  = value.enableArrow
+        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
+        value_enableArrow_type = runtimeType(value_enableArrow)
+        valueSerializer.writeInt8((value_enableArrow_type).toChar())
+        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableArrow_value  = value_enableArrow!
+            valueSerializer.writeBoolean(value_enableArrow_value)
         }
-        const value_fontSize  = value.fontSize
-        let value_fontSize_type : int32 = RuntimeType.UNDEFINED
-        value_fontSize_type = runtimeType(value_fontSize)
-        valueSerializer.writeInt8((value_fontSize_type).toChar())
-        if ((value_fontSize_type) != (RuntimeType.UNDEFINED)) {
-            const value_fontSize_value  = value_fontSize!
-            let value_fontSize_value_type : int32 = RuntimeType.UNDEFINED
-            value_fontSize_value_type = runtimeType(value_fontSize_value)
-            if (RuntimeType.STRING == value_fontSize_value_type) {
+        const value_arrowOffset  = value.arrowOffset
+        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
+        value_arrowOffset_type = runtimeType(value_arrowOffset)
+        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
+        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowOffset_value  = value_arrowOffset!
+            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
+            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
+            if (RuntimeType.STRING == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_fontSize_value_0  = value_fontSize_value as string
-                valueSerializer.writeString(value_fontSize_value_0)
+                const value_arrowOffset_value_0  = value_arrowOffset_value as string
+                valueSerializer.writeString(value_arrowOffset_value_0)
             }
-            else if (RuntimeType.NUMBER == value_fontSize_value_type) {
+            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_fontSize_value_1  = value_fontSize_value as number
-                valueSerializer.writeNumber(value_fontSize_value_1)
+                const value_arrowOffset_value_1  = value_arrowOffset_value as number
+                valueSerializer.writeNumber(value_arrowOffset_value_1)
             }
-            else if (RuntimeType.OBJECT == value_fontSize_value_type) {
+            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_fontSize_value_2  = value_fontSize_value as Resource
-                Resource_serializer.write(valueSerializer, value_fontSize_value_2)
+                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
+                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
             }
         }
-        const value_fontColor  = value.fontColor
-        let value_fontColor_type : int32 = RuntimeType.UNDEFINED
-        value_fontColor_type = runtimeType(value_fontColor)
-        valueSerializer.writeInt8((value_fontColor_type).toChar())
-        if ((value_fontColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_fontColor_value  = value_fontColor!
-            let value_fontColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_fontColor_value_type = runtimeType(value_fontColor_value)
-            if (TypeChecker.isColor(value_fontColor_value)) {
+        const value_preview  = value.preview
+        let value_preview_type : int32 = RuntimeType.UNDEFINED
+        value_preview_type = runtimeType(value_preview)
+        valueSerializer.writeInt8((value_preview_type).toChar())
+        if ((value_preview_type) != (RuntimeType.UNDEFINED)) {
+            const value_preview_value  = value_preview!
+            let value_preview_value_type : int32 = RuntimeType.UNDEFINED
+            value_preview_value_type = runtimeType(value_preview_value)
+            if (TypeChecker.isMenuPreviewMode(value_preview_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_fontColor_value_0  = value_fontColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_fontColor_value_0))
+                const value_preview_value_0  = value_preview_value as MenuPreviewMode
+                valueSerializer.writeInt32(TypeChecker.MenuPreviewMode_ToNumeric(value_preview_value_0))
             }
-            else if (RuntimeType.NUMBER == value_fontColor_value_type) {
+            else if (RuntimeType.FUNCTION == value_preview_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_fontColor_value_1  = value_fontColor_value as number
-                valueSerializer.writeNumber(value_fontColor_value_1)
-            }
-            else if (RuntimeType.STRING == value_fontColor_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_fontColor_value_2  = value_fontColor_value as string
-                valueSerializer.writeString(value_fontColor_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_fontColor_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_fontColor_value_3  = value_fontColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_fontColor_value_3)
+                const value_preview_value_1  = value_preview_value as CustomBuilder
+                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_preview_value_1))
             }
         }
-        const value_fontWeight  = value.fontWeight
-        let value_fontWeight_type : int32 = RuntimeType.UNDEFINED
-        value_fontWeight_type = runtimeType(value_fontWeight)
-        valueSerializer.writeInt8((value_fontWeight_type).toChar())
-        if ((value_fontWeight_type) != (RuntimeType.UNDEFINED)) {
-            const value_fontWeight_value  = value_fontWeight!
-            let value_fontWeight_value_type : int32 = RuntimeType.UNDEFINED
-            value_fontWeight_value_type = runtimeType(value_fontWeight_value)
-            if (TypeChecker.isFontWeight(value_fontWeight_value)) {
+        const value_previewBorderRadius  = value.previewBorderRadius
+        let value_previewBorderRadius_type : int32 = RuntimeType.UNDEFINED
+        value_previewBorderRadius_type = runtimeType(value_previewBorderRadius)
+        valueSerializer.writeInt8((value_previewBorderRadius_type).toChar())
+        if ((value_previewBorderRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_previewBorderRadius_value  = value_previewBorderRadius!
+            let value_previewBorderRadius_value_type : int32 = RuntimeType.UNDEFINED
+            value_previewBorderRadius_value_type = runtimeType(value_previewBorderRadius_value)
+            if ((RuntimeType.STRING == value_previewBorderRadius_value_type) || (RuntimeType.NUMBER == value_previewBorderRadius_value_type) || (RuntimeType.OBJECT == value_previewBorderRadius_value_type)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_fontWeight_value_0  = value_fontWeight_value as FontWeight
-                valueSerializer.writeInt32(TypeChecker.FontWeight_ToNumeric(value_fontWeight_value_0))
+                const value_previewBorderRadius_value_0  = value_previewBorderRadius_value as Length
+                let value_previewBorderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_previewBorderRadius_value_0_type = runtimeType(value_previewBorderRadius_value_0)
+                if (RuntimeType.STRING == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_previewBorderRadius_value_0_0  = value_previewBorderRadius_value_0 as string
+                    valueSerializer.writeString(value_previewBorderRadius_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_previewBorderRadius_value_0_1  = value_previewBorderRadius_value_0 as number
+                    valueSerializer.writeNumber(value_previewBorderRadius_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_previewBorderRadius_value_0_2  = value_previewBorderRadius_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_previewBorderRadius_value_0_2)
+                }
             }
-            else if (RuntimeType.NUMBER == value_fontWeight_value_type) {
+            else if (TypeChecker.isBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_fontWeight_value_1  = value_fontWeight_value as number
-                valueSerializer.writeNumber(value_fontWeight_value_1)
+                const value_previewBorderRadius_value_1  = value_previewBorderRadius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_1)
             }
-            else if (RuntimeType.STRING == value_fontWeight_value_type) {
+            else if (TypeChecker.isLocalizedBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_fontWeight_value_2  = value_fontWeight_value as string
-                valueSerializer.writeString(value_fontWeight_value_2)
+                const value_previewBorderRadius_value_2  = value_previewBorderRadius_value as LocalizedBorderRadiuses
+                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_2)
             }
         }
-        const value_fontStyle  = value.fontStyle
-        let value_fontStyle_type : int32 = RuntimeType.UNDEFINED
-        value_fontStyle_type = runtimeType(value_fontStyle)
-        valueSerializer.writeInt8((value_fontStyle_type).toChar())
-        if ((value_fontStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_fontStyle_value  = (value_fontStyle as FontStyle)
-            valueSerializer.writeInt32(TypeChecker.FontStyle_ToNumeric(value_fontStyle_value))
-        }
-        const value_fontFamily  = value.fontFamily
-        let value_fontFamily_type : int32 = RuntimeType.UNDEFINED
-        value_fontFamily_type = runtimeType(value_fontFamily)
-        valueSerializer.writeInt8((value_fontFamily_type).toChar())
-        if ((value_fontFamily_type) != (RuntimeType.UNDEFINED)) {
-            const value_fontFamily_value  = value_fontFamily!
-            let value_fontFamily_value_type : int32 = RuntimeType.UNDEFINED
-            value_fontFamily_value_type = runtimeType(value_fontFamily_value)
-            if (RuntimeType.OBJECT == value_fontFamily_value_type) {
+        const value_borderRadius  = value.borderRadius
+        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
+        value_borderRadius_type = runtimeType(value_borderRadius)
+        valueSerializer.writeInt8((value_borderRadius_type).toChar())
+        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderRadius_value  = value_borderRadius!
+            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
+            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_fontFamily_value_0  = value_fontFamily_value as Resource
-                Resource_serializer.write(valueSerializer, value_fontFamily_value_0)
+                const value_borderRadius_value_0  = value_borderRadius_value as Length
+                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
+                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
+                    valueSerializer.writeString(value_borderRadius_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
+                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
+                }
             }
-            else if (RuntimeType.STRING == value_fontFamily_value_type) {
+            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_fontFamily_value_1  = value_fontFamily_value as string
-                valueSerializer.writeString(value_fontFamily_value_1)
+                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
+            }
+            else if (TypeChecker.isLocalizedBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_borderRadius_value_2  = value_borderRadius_value as LocalizedBorderRadiuses
+                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_2)
             }
         }
+        const value_onAppear  = value.onAppear
+        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onAppear_type = runtimeType(value_onAppear)
+        valueSerializer.writeInt8((value_onAppear_type).toChar())
+        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onAppear_value  = value_onAppear!
+            valueSerializer.holdAndWriteCallback(value_onAppear_value)
+        }
+        const value_onDisappear  = value.onDisappear
+        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onDisappear_type = runtimeType(value_onDisappear)
+        valueSerializer.writeInt8((value_onDisappear_type).toChar())
+        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onDisappear_value  = value_onDisappear!
+            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
+        }
+        const value_aboutToAppear  = value.aboutToAppear
+        let value_aboutToAppear_type : int32 = RuntimeType.UNDEFINED
+        value_aboutToAppear_type = runtimeType(value_aboutToAppear)
+        valueSerializer.writeInt8((value_aboutToAppear_type).toChar())
+        if ((value_aboutToAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_aboutToAppear_value  = value_aboutToAppear!
+            valueSerializer.holdAndWriteCallback(value_aboutToAppear_value)
+        }
+        const value_aboutToDisappear  = value.aboutToDisappear
+        let value_aboutToDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_aboutToDisappear_type = runtimeType(value_aboutToDisappear)
+        valueSerializer.writeInt8((value_aboutToDisappear_type).toChar())
+        if ((value_aboutToDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_aboutToDisappear_value  = value_aboutToDisappear!
+            valueSerializer.holdAndWriteCallback(value_aboutToDisappear_value)
+        }
+        const value_layoutRegionMargin  = value.layoutRegionMargin
+        let value_layoutRegionMargin_type : int32 = RuntimeType.UNDEFINED
+        value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin)
+        valueSerializer.writeInt8((value_layoutRegionMargin_type).toChar())
+        if ((value_layoutRegionMargin_type) != (RuntimeType.UNDEFINED)) {
+            const value_layoutRegionMargin_value  = value_layoutRegionMargin!
+            Padding_serializer.write(valueSerializer, value_layoutRegionMargin_value)
+        }
+        const value_previewAnimationOptions  = value.previewAnimationOptions
+        let value_previewAnimationOptions_type : int32 = RuntimeType.UNDEFINED
+        value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions)
+        valueSerializer.writeInt8((value_previewAnimationOptions_type).toChar())
+        if ((value_previewAnimationOptions_type) != (RuntimeType.UNDEFINED)) {
+            const value_previewAnimationOptions_value  = value_previewAnimationOptions!
+            ContextMenuAnimationOptions_serializer.write(valueSerializer, value_previewAnimationOptions_value)
+        }
         const value_backgroundColor  = value.backgroundColor
         let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
         value_backgroundColor_type = runtimeType(value_backgroundColor)
@@ -19465,194 +19922,243 @@ export class PickerDialogButtonStyle_serializer {
                 Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
             }
         }
-        const value_borderRadius  = value.borderRadius
-        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
-        value_borderRadius_type = runtimeType(value_borderRadius)
-        valueSerializer.writeInt8((value_borderRadius_type).toChar())
-        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderRadius_value  = value_borderRadius!
-            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
-            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
+        const value_backgroundBlurStyle  = value.backgroundBlurStyle
+        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
+        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
+        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
+            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
+        }
+        const value_backgroundBlurStyleOptions  = value.backgroundBlurStyleOptions
+        let value_backgroundBlurStyleOptions_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions)
+        valueSerializer.writeInt8((value_backgroundBlurStyleOptions_type).toChar())
+        if ((value_backgroundBlurStyleOptions_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundBlurStyleOptions_value  = value_backgroundBlurStyleOptions!
+            BackgroundBlurStyleOptions_serializer.write(valueSerializer, value_backgroundBlurStyleOptions_value)
+        }
+        const value_backgroundEffect  = value.backgroundEffect
+        let value_backgroundEffect_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundEffect_type = runtimeType(value_backgroundEffect)
+        valueSerializer.writeInt8((value_backgroundEffect_type).toChar())
+        if ((value_backgroundEffect_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundEffect_value  = value_backgroundEffect!
+            BackgroundEffectOptions_serializer.write(valueSerializer, value_backgroundEffect_value)
+        }
+        const value_transition  = value.transition
+        let value_transition_type : int32 = RuntimeType.UNDEFINED
+        value_transition_type = runtimeType(value_transition)
+        valueSerializer.writeInt8((value_transition_type).toChar())
+        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
+            const value_transition_value  = value_transition!
+            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
+        }
+        const value_enableHoverMode  = value.enableHoverMode
+        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
+        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
+        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
+        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableHoverMode_value  = value_enableHoverMode!
+            valueSerializer.writeBoolean(value_enableHoverMode_value)
+        }
+        const value_outlineColor  = value.outlineColor
+        let value_outlineColor_type : int32 = RuntimeType.UNDEFINED
+        value_outlineColor_type = runtimeType(value_outlineColor)
+        valueSerializer.writeInt8((value_outlineColor_type).toChar())
+        if ((value_outlineColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_outlineColor_value  = value_outlineColor!
+            let value_outlineColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_outlineColor_value_type = runtimeType(value_outlineColor_value)
+            if ((TypeChecker.isColor(value_outlineColor_value)) || (RuntimeType.NUMBER == value_outlineColor_value_type) || (RuntimeType.STRING == value_outlineColor_value_type) || (RuntimeType.OBJECT == value_outlineColor_value_type)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_borderRadius_value_0  = value_borderRadius_value as Length
-                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
-                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
+                const value_outlineColor_value_0  = value_outlineColor_value as ResourceColor
+                let value_outlineColor_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_outlineColor_value_0_type = runtimeType(value_outlineColor_value_0)
+                if (TypeChecker.isColor(value_outlineColor_value_0)) {
                     valueSerializer.writeInt8((0).toChar())
-                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
-                    valueSerializer.writeString(value_borderRadius_value_0_0)
+                    const value_outlineColor_value_0_0  = value_outlineColor_value_0 as Color
+                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_outlineColor_value_0_0))
                 }
-                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
+                else if (RuntimeType.NUMBER == value_outlineColor_value_0_type) {
                     valueSerializer.writeInt8((1).toChar())
-                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
-                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
+                    const value_outlineColor_value_0_1  = value_outlineColor_value_0 as number
+                    valueSerializer.writeNumber(value_outlineColor_value_0_1)
                 }
-                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
+                else if (RuntimeType.STRING == value_outlineColor_value_0_type) {
                     valueSerializer.writeInt8((2).toChar())
-                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
+                    const value_outlineColor_value_0_2  = value_outlineColor_value_0 as string
+                    valueSerializer.writeString(value_outlineColor_value_0_2)
+                }
+                else if (RuntimeType.OBJECT == value_outlineColor_value_0_type) {
+                    valueSerializer.writeInt8((3).toChar())
+                    const value_outlineColor_value_0_3  = value_outlineColor_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_outlineColor_value_0_3)
                 }
             }
-            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+            else if (TypeChecker.isEdgeColors(value_outlineColor_value, false, false, false, false)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
+                const value_outlineColor_value_1  = value_outlineColor_value as EdgeColors
+                EdgeColors_serializer.write(valueSerializer, value_outlineColor_value_1)
             }
         }
-        const value_primary  = value.primary
-        let value_primary_type : int32 = RuntimeType.UNDEFINED
-        value_primary_type = runtimeType(value_primary)
-        valueSerializer.writeInt8((value_primary_type).toChar())
-        if ((value_primary_type) != (RuntimeType.UNDEFINED)) {
-            const value_primary_value  = value_primary!
-            valueSerializer.writeBoolean(value_primary_value)
+        const value_outlineWidth  = value.outlineWidth
+        let value_outlineWidth_type : int32 = RuntimeType.UNDEFINED
+        value_outlineWidth_type = runtimeType(value_outlineWidth)
+        valueSerializer.writeInt8((value_outlineWidth_type).toChar())
+        if ((value_outlineWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_outlineWidth_value  = value_outlineWidth!
+            let value_outlineWidth_value_type : int32 = RuntimeType.UNDEFINED
+            value_outlineWidth_value_type = runtimeType(value_outlineWidth_value)
+            if ((RuntimeType.STRING == value_outlineWidth_value_type) || (RuntimeType.NUMBER == value_outlineWidth_value_type) || (RuntimeType.OBJECT == value_outlineWidth_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_outlineWidth_value_0  = value_outlineWidth_value as Dimension
+                let value_outlineWidth_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_outlineWidth_value_0_type = runtimeType(value_outlineWidth_value_0)
+                if (RuntimeType.STRING == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_outlineWidth_value_0_0  = value_outlineWidth_value_0 as string
+                    valueSerializer.writeString(value_outlineWidth_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_outlineWidth_value_0_1  = value_outlineWidth_value_0 as number
+                    valueSerializer.writeNumber(value_outlineWidth_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_outlineWidth_value_0_2  = value_outlineWidth_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_outlineWidth_value_0_2)
+                }
+            }
+            else if (TypeChecker.isEdgeOutlineWidths(value_outlineWidth_value, false, false, false, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_outlineWidth_value_1  = value_outlineWidth_value as EdgeOutlineWidths
+                EdgeOutlineWidths_serializer.write(valueSerializer, value_outlineWidth_value_1)
+            }
+        }
+        const value_hapticFeedbackMode  = value.hapticFeedbackMode
+        let value_hapticFeedbackMode_type : int32 = RuntimeType.UNDEFINED
+        value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode)
+        valueSerializer.writeInt8((value_hapticFeedbackMode_type).toChar())
+        if ((value_hapticFeedbackMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_hapticFeedbackMode_value  = (value_hapticFeedbackMode as HapticFeedbackMode)
+            valueSerializer.writeInt32(TypeChecker.HapticFeedbackMode_ToNumeric(value_hapticFeedbackMode_value))
         }
     }
-    public static read(buffer: DeserializerBase): PickerDialogButtonStyle {
+    public static read(buffer: DeserializerBase): ContextMenuOptions {
         let valueDeserializer : DeserializerBase = buffer
-        const type_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let type_buf : ButtonType | undefined
-        if ((type_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offset_buf : Position | undefined
+        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            type_buf = TypeChecker.ButtonType_FromNumeric(valueDeserializer.readInt32())
+            offset_buf = Position_serializer.read(valueDeserializer)
         }
-        const type_result : ButtonType | undefined = type_buf
-        const style_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let style_buf : ButtonStyleMode | undefined
-        if ((style_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const offset_result : Position | undefined = offset_buf
+        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let placement_buf : Placement | undefined
+        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            style_buf = TypeChecker.ButtonStyleMode_FromNumeric(valueDeserializer.readInt32())
+            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
         }
-        const style_result : ButtonStyleMode | undefined = style_buf
-        const role_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let role_buf : ButtonRole | undefined
-        if ((role_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            role_buf = TypeChecker.ButtonRole_FromNumeric(valueDeserializer.readInt32())
-        }
-        const role_result : ButtonRole | undefined = role_buf
-        const fontSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fontSize_buf : Length | undefined
-        if ((fontSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const fontSize_buf__selector : int32 = valueDeserializer.readInt8()
-            let fontSize_buf_ : string | number | Resource | undefined
-            if (fontSize_buf__selector == (0).toChar()) {
-                fontSize_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (fontSize_buf__selector == (1).toChar()) {
-                fontSize_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (fontSize_buf__selector == (2).toChar()) {
-                fontSize_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for fontSize_buf_ has to be chosen through deserialisation.")
-            }
-            fontSize_buf = (fontSize_buf_ as string | number | Resource)
-        }
-        const fontSize_result : Length | undefined = fontSize_buf
-        const fontColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fontColor_buf : ResourceColor | undefined
-        if ((fontColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const placement_result : Placement | undefined = placement_buf
+        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableArrow_buf : boolean | undefined
+        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const fontColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let fontColor_buf_ : Color | number | string | Resource | undefined
-            if (fontColor_buf__selector == (0).toChar()) {
-                fontColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (fontColor_buf__selector == (1).toChar()) {
-                fontColor_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (fontColor_buf__selector == (2).toChar()) {
-                fontColor_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (fontColor_buf__selector == (3).toChar()) {
-                fontColor_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for fontColor_buf_ has to be chosen through deserialisation.")
-            }
-            fontColor_buf = (fontColor_buf_ as Color | number | string | Resource)
+            enableArrow_buf = valueDeserializer.readBoolean()
         }
-        const fontColor_result : ResourceColor | undefined = fontColor_buf
-        const fontWeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fontWeight_buf : FontWeight | number | string | undefined
-        if ((fontWeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const enableArrow_result : boolean | undefined = enableArrow_buf
+        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowOffset_buf : Length | undefined
+        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const fontWeight_buf__selector : int32 = valueDeserializer.readInt8()
-            let fontWeight_buf_ : FontWeight | number | string | undefined
-            if (fontWeight_buf__selector == (0).toChar()) {
-                fontWeight_buf_ = TypeChecker.FontWeight_FromNumeric(valueDeserializer.readInt32())
+            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
+            let arrowOffset_buf_ : string | number | Resource | undefined
+            if (arrowOffset_buf__selector == (0).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (fontWeight_buf__selector == (1).toChar()) {
-                fontWeight_buf_ = (valueDeserializer.readNumber() as number)
+            else if (arrowOffset_buf__selector == (1).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (fontWeight_buf__selector == (2).toChar()) {
-                fontWeight_buf_ = (valueDeserializer.readString() as string)
+            else if (arrowOffset_buf__selector == (2).toChar()) {
+                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
             }
-            fontWeight_buf = (fontWeight_buf_ as FontWeight | number | string)
-        }
-        const fontWeight_result : FontWeight | number | string | undefined = fontWeight_buf
-        const fontStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fontStyle_buf : FontStyle | undefined
-        if ((fontStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            fontStyle_buf = TypeChecker.FontStyle_FromNumeric(valueDeserializer.readInt32())
+            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
         }
-        const fontStyle_result : FontStyle | undefined = fontStyle_buf
-        const fontFamily_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let fontFamily_buf : Resource | string | undefined
-        if ((fontFamily_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const arrowOffset_result : Length | undefined = arrowOffset_buf
+        const preview_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let preview_buf : MenuPreviewMode | CustomBuilder | undefined
+        if ((preview_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const fontFamily_buf__selector : int32 = valueDeserializer.readInt8()
-            let fontFamily_buf_ : Resource | string | undefined
-            if (fontFamily_buf__selector == (0).toChar()) {
-                fontFamily_buf_ = Resource_serializer.read(valueDeserializer)
+            const preview_buf__selector : int32 = valueDeserializer.readInt8()
+            let preview_buf_ : MenuPreviewMode | CustomBuilder | undefined
+            if (preview_buf__selector == (0).toChar()) {
+                preview_buf_ = TypeChecker.MenuPreviewMode_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (fontFamily_buf__selector == (1).toChar()) {
-                fontFamily_buf_ = (valueDeserializer.readString() as string)
+            else if (preview_buf__selector == (1).toChar()) {
+                const preview_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
+                const preview_buf__u_call : KPointer = valueDeserializer.readPointer()
+                const preview_buf__u_callSync : KPointer = valueDeserializer.readPointer()
+                preview_buf_ = ():void => { 
+    const preview_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
+    preview_buf__u_argsSerializer.writeInt32(preview_buf__u_resource.resourceId);
+    preview_buf__u_argsSerializer.writePointer(preview_buf__u_call);
+    preview_buf__u_argsSerializer.writePointer(preview_buf__u_callSync);
+    InteropNativeModule._CallCallback(737226752, preview_buf__u_argsSerializer.asBuffer(), preview_buf__u_argsSerializer.length());
+    preview_buf__u_argsSerializer.release();
+    return; }
             }
             else {
-                throw new Error("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for preview_buf_ has to be chosen through deserialisation.")
             }
-            fontFamily_buf = (fontFamily_buf_ as Resource | string)
+            preview_buf = (preview_buf_ as MenuPreviewMode | CustomBuilder)
         }
-        const fontFamily_result : Resource | string | undefined = fontFamily_buf
-        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundColor_buf : ResourceColor | undefined
-        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const preview_result : MenuPreviewMode | CustomBuilder | undefined = preview_buf
+        const previewBorderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let previewBorderRadius_buf : BorderRadiusType | undefined
+        if ((previewBorderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let backgroundColor_buf_ : Color | number | string | Resource | undefined
-            if (backgroundColor_buf__selector == (0).toChar()) {
-                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (backgroundColor_buf__selector == (1).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+            const previewBorderRadius_buf__selector : int32 = valueDeserializer.readInt8()
+            let previewBorderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
+            if (previewBorderRadius_buf__selector == (0).toChar()) {
+                const previewBorderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let previewBorderRadius_buf__u : string | number | Resource | undefined
+                if (previewBorderRadius_buf__u_selector == (0).toChar()) {
+                    previewBorderRadius_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (previewBorderRadius_buf__u_selector == (1).toChar()) {
+                    previewBorderRadius_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (previewBorderRadius_buf__u_selector == (2).toChar()) {
+                    previewBorderRadius_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.")
+                }
+                previewBorderRadius_buf_ = (previewBorderRadius_buf__u as string | number | Resource)
             }
-            else if (backgroundColor_buf__selector == (2).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readString() as string)
+            else if (previewBorderRadius_buf__selector == (1).toChar()) {
+                previewBorderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
-            else if (backgroundColor_buf__selector == (3).toChar()) {
-                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (previewBorderRadius_buf__selector == (2).toChar()) {
+                previewBorderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.")
             }
-            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
+            previewBorderRadius_buf = (previewBorderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
         }
-        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const previewBorderRadius_result : BorderRadiusType | undefined = previewBorderRadius_buf
         const borderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderRadius_buf : Length | BorderRadiuses | undefined
+        let borderRadius_buf : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
         if ((borderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
             const borderRadius_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderRadius_buf_ : Length | BorderRadiuses | undefined
+            let borderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
             if (borderRadius_buf__selector == (0).toChar()) {
                 const borderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
                 let borderRadius_buf__u : string | number | Resource | undefined
@@ -19673,506 +20179,382 @@ export class PickerDialogButtonStyle_serializer {
             else if (borderRadius_buf__selector == (1).toChar()) {
                 borderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
+            else if (borderRadius_buf__selector == (2).toChar()) {
+                borderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
+            }
             else {
                 throw new Error("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.")
             }
-            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses)
+            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
         }
-        const borderRadius_result : Length | BorderRadiuses | undefined = borderRadius_buf
-        const primary_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let primary_buf : boolean | undefined
-        if ((primary_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderRadius_result : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined = borderRadius_buf
+        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onAppear_buf : (() => void) | undefined
+        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            primary_buf = valueDeserializer.readBoolean()
-        }
-        const primary_result : boolean | undefined = primary_buf
-        let value : PickerDialogButtonStyle = ({type: type_result, style: style_result, role: role_result, fontSize: fontSize_result, fontColor: fontColor_result, fontWeight: fontWeight_result, fontStyle: fontStyle_result, fontFamily: fontFamily_result, backgroundColor: backgroundColor_result, borderRadius: borderRadius_result, primary: primary_result} as PickerDialogButtonStyle)
-        return value
-    }
-}
-export class PickerTextStyle_serializer {
-    public static write(buffer: SerializerBase, value: PickerTextStyle): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_color  = value.color
-        let value_color_type : int32 = RuntimeType.UNDEFINED
-        value_color_type = runtimeType(value_color)
-        valueSerializer.writeInt8((value_color_type).toChar())
-        if ((value_color_type) != (RuntimeType.UNDEFINED)) {
-            const value_color_value  = value_color!
-            let value_color_value_type : int32 = RuntimeType.UNDEFINED
-            value_color_value_type = runtimeType(value_color_value)
-            if (TypeChecker.isColor(value_color_value)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_color_value_0  = value_color_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_color_value_0))
-            }
-            else if (RuntimeType.NUMBER == value_color_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_color_value_1  = value_color_value as number
-                valueSerializer.writeNumber(value_color_value_1)
-            }
-            else if (RuntimeType.STRING == value_color_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_color_value_2  = value_color_value as string
-                valueSerializer.writeString(value_color_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_color_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_color_value_3  = value_color_value as Resource
-                Resource_serializer.write(valueSerializer, value_color_value_3)
-            }
-        }
-        const value_font  = value.font
-        let value_font_type : int32 = RuntimeType.UNDEFINED
-        value_font_type = runtimeType(value_font)
-        valueSerializer.writeInt8((value_font_type).toChar())
-        if ((value_font_type) != (RuntimeType.UNDEFINED)) {
-            const value_font_value  = value_font!
-            Font_serializer.write(valueSerializer, value_font_value)
+            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onAppear_buf = ():void => { 
+    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
+    onAppear_buf__argsSerializer.release();
+    return; }
         }
-    }
-    public static read(buffer: DeserializerBase): PickerTextStyle {
-        let valueDeserializer : DeserializerBase = buffer
-        const color_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let color_buf : ResourceColor | undefined
-        if ((color_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const onAppear_result : (() => void) | undefined = onAppear_buf
+        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onDisappear_buf : (() => void) | undefined
+        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const color_buf__selector : int32 = valueDeserializer.readInt8()
-            let color_buf_ : Color | number | string | Resource | undefined
-            if (color_buf__selector == (0).toChar()) {
-                color_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onDisappear_buf = ():void => { 
+    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
+    onDisappear_buf__argsSerializer.release();
+    return; }
+        }
+        const onDisappear_result : (() => void) | undefined = onDisappear_buf
+        const aboutToAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let aboutToAppear_buf : (() => void) | undefined
+        if ((aboutToAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const aboutToAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const aboutToAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const aboutToAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            aboutToAppear_buf = ():void => { 
+    const aboutToAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    aboutToAppear_buf__argsSerializer.writeInt32(aboutToAppear_buf__resource.resourceId);
+    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__call);
+    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, aboutToAppear_buf__argsSerializer.asBuffer(), aboutToAppear_buf__argsSerializer.length());
+    aboutToAppear_buf__argsSerializer.release();
+    return; }
+        }
+        const aboutToAppear_result : (() => void) | undefined = aboutToAppear_buf
+        const aboutToDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let aboutToDisappear_buf : (() => void) | undefined
+        if ((aboutToDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const aboutToDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const aboutToDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const aboutToDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            aboutToDisappear_buf = ():void => { 
+    const aboutToDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    aboutToDisappear_buf__argsSerializer.writeInt32(aboutToDisappear_buf__resource.resourceId);
+    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__call);
+    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, aboutToDisappear_buf__argsSerializer.asBuffer(), aboutToDisappear_buf__argsSerializer.length());
+    aboutToDisappear_buf__argsSerializer.release();
+    return; }
+        }
+        const aboutToDisappear_result : (() => void) | undefined = aboutToDisappear_buf
+        const layoutRegionMargin_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let layoutRegionMargin_buf : Padding | undefined
+        if ((layoutRegionMargin_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            layoutRegionMargin_buf = Padding_serializer.read(valueDeserializer)
+        }
+        const layoutRegionMargin_result : Padding | undefined = layoutRegionMargin_buf
+        const previewAnimationOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let previewAnimationOptions_buf : ContextMenuAnimationOptions | undefined
+        if ((previewAnimationOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            previewAnimationOptions_buf = ContextMenuAnimationOptions_serializer.read(valueDeserializer)
+        }
+        const previewAnimationOptions_result : ContextMenuAnimationOptions | undefined = previewAnimationOptions_buf
+        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundColor_buf : ResourceColor | undefined
+        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let backgroundColor_buf_ : Color | number | string | Resource | undefined
+            if (backgroundColor_buf__selector == (0).toChar()) {
+                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (color_buf__selector == (1).toChar()) {
-                color_buf_ = (valueDeserializer.readNumber() as number)
+            else if (backgroundColor_buf__selector == (1).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (color_buf__selector == (2).toChar()) {
-                color_buf_ = (valueDeserializer.readString() as string)
+            else if (backgroundColor_buf__selector == (2).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (color_buf__selector == (3).toChar()) {
-                color_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (backgroundColor_buf__selector == (3).toChar()) {
+                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for color_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
             }
-            color_buf = (color_buf_ as Color | number | string | Resource)
+            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
         }
-        const color_result : ResourceColor | undefined = color_buf
-        const font_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let font_buf : Font | undefined
-        if ((font_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundBlurStyle_buf : BlurStyle | undefined
+        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            font_buf = Font_serializer.read(valueDeserializer)
+            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const font_result : Font | undefined = font_buf
-        let value : PickerTextStyle = ({color: color_result, font: font_result} as PickerTextStyle)
-        return value
-    }
-}
-export class PopupMessageOptions_serializer {
-    public static write(buffer: SerializerBase, value: PopupMessageOptions): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_textColor  = value.textColor
-        let value_textColor_type : int32 = RuntimeType.UNDEFINED
-        value_textColor_type = runtimeType(value_textColor)
-        valueSerializer.writeInt8((value_textColor_type).toChar())
-        if ((value_textColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_textColor_value  = value_textColor!
-            let value_textColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_textColor_value_type = runtimeType(value_textColor_value)
-            if (TypeChecker.isColor(value_textColor_value)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_textColor_value_0  = value_textColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_textColor_value_0))
-            }
-            else if (RuntimeType.NUMBER == value_textColor_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_textColor_value_1  = value_textColor_value as number
-                valueSerializer.writeNumber(value_textColor_value_1)
-            }
-            else if (RuntimeType.STRING == value_textColor_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_textColor_value_2  = value_textColor_value as string
-                valueSerializer.writeString(value_textColor_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_textColor_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_textColor_value_3  = value_textColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_textColor_value_3)
-            }
+        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
+        const backgroundBlurStyleOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundBlurStyleOptions_buf : BackgroundBlurStyleOptions | undefined
+        if ((backgroundBlurStyleOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            backgroundBlurStyleOptions_buf = BackgroundBlurStyleOptions_serializer.read(valueDeserializer)
         }
-        const value_font  = value.font
-        let value_font_type : int32 = RuntimeType.UNDEFINED
-        value_font_type = runtimeType(value_font)
-        valueSerializer.writeInt8((value_font_type).toChar())
-        if ((value_font_type) != (RuntimeType.UNDEFINED)) {
-            const value_font_value  = value_font!
-            Font_serializer.write(valueSerializer, value_font_value)
+        const backgroundBlurStyleOptions_result : BackgroundBlurStyleOptions | undefined = backgroundBlurStyleOptions_buf
+        const backgroundEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundEffect_buf : BackgroundEffectOptions | undefined
+        if ((backgroundEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            backgroundEffect_buf = BackgroundEffectOptions_serializer.read(valueDeserializer)
         }
-    }
-    public static read(buffer: DeserializerBase): PopupMessageOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const textColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let textColor_buf : ResourceColor | undefined
-        if ((textColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundEffect_result : BackgroundEffectOptions | undefined = backgroundEffect_buf
+        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let transition_buf : TransitionEffect | undefined
+        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const textColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let textColor_buf_ : Color | number | string | Resource | undefined
-            if (textColor_buf__selector == (0).toChar()) {
-                textColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+        }
+        const transition_result : TransitionEffect | undefined = transition_buf
+        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableHoverMode_buf : boolean | undefined
+        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            enableHoverMode_buf = valueDeserializer.readBoolean()
+        }
+        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
+        const outlineColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let outlineColor_buf : ResourceColor | EdgeColors | undefined
+        if ((outlineColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const outlineColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let outlineColor_buf_ : ResourceColor | EdgeColors | undefined
+            if (outlineColor_buf__selector == (0).toChar()) {
+                const outlineColor_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let outlineColor_buf__u : Color | number | string | Resource | undefined
+                if (outlineColor_buf__u_selector == (0).toChar()) {
+                    outlineColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+                }
+                else if (outlineColor_buf__u_selector == (1).toChar()) {
+                    outlineColor_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (outlineColor_buf__u_selector == (2).toChar()) {
+                    outlineColor_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (outlineColor_buf__u_selector == (3).toChar()) {
+                    outlineColor_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.")
+                }
+                outlineColor_buf_ = (outlineColor_buf__u as Color | number | string | Resource)
             }
-            else if (textColor_buf__selector == (1).toChar()) {
-                textColor_buf_ = (valueDeserializer.readNumber() as number)
+            else if (outlineColor_buf__selector == (1).toChar()) {
+                outlineColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
             }
-            else if (textColor_buf__selector == (2).toChar()) {
-                textColor_buf_ = (valueDeserializer.readString() as string)
+            else {
+                throw new Error("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.")
             }
-            else if (textColor_buf__selector == (3).toChar()) {
-                textColor_buf_ = Resource_serializer.read(valueDeserializer)
+            outlineColor_buf = (outlineColor_buf_ as ResourceColor | EdgeColors)
+        }
+        const outlineColor_result : ResourceColor | EdgeColors | undefined = outlineColor_buf
+        const outlineWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let outlineWidth_buf : Dimension | EdgeOutlineWidths | undefined
+        if ((outlineWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const outlineWidth_buf__selector : int32 = valueDeserializer.readInt8()
+            let outlineWidth_buf_ : Dimension | EdgeOutlineWidths | undefined
+            if (outlineWidth_buf__selector == (0).toChar()) {
+                const outlineWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let outlineWidth_buf__u : string | number | Resource | undefined
+                if (outlineWidth_buf__u_selector == (0).toChar()) {
+                    outlineWidth_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (outlineWidth_buf__u_selector == (1).toChar()) {
+                    outlineWidth_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (outlineWidth_buf__u_selector == (2).toChar()) {
+                    outlineWidth_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.")
+                }
+                outlineWidth_buf_ = (outlineWidth_buf__u as string | number | Resource)
+            }
+            else if (outlineWidth_buf__selector == (1).toChar()) {
+                outlineWidth_buf_ = EdgeOutlineWidths_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for textColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.")
             }
-            textColor_buf = (textColor_buf_ as Color | number | string | Resource)
+            outlineWidth_buf = (outlineWidth_buf_ as Dimension | EdgeOutlineWidths)
         }
-        const textColor_result : ResourceColor | undefined = textColor_buf
-        const font_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let font_buf : Font | undefined
-        if ((font_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const outlineWidth_result : Dimension | EdgeOutlineWidths | undefined = outlineWidth_buf
+        const hapticFeedbackMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let hapticFeedbackMode_buf : HapticFeedbackMode | undefined
+        if ((hapticFeedbackMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            font_buf = Font_serializer.read(valueDeserializer)
+            hapticFeedbackMode_buf = TypeChecker.HapticFeedbackMode_FromNumeric(valueDeserializer.readInt32())
         }
-        const font_result : Font | undefined = font_buf
-        let value : PopupMessageOptions = ({textColor: textColor_result, font: font_result} as PopupMessageOptions)
+        const hapticFeedbackMode_result : HapticFeedbackMode | undefined = hapticFeedbackMode_buf
+        let value : ContextMenuOptions = ({offset: offset_result, placement: placement_result, enableArrow: enableArrow_result, arrowOffset: arrowOffset_result, preview: preview_result, previewBorderRadius: previewBorderRadius_result, borderRadius: borderRadius_result, onAppear: onAppear_result, onDisappear: onDisappear_result, aboutToAppear: aboutToAppear_result, aboutToDisappear: aboutToDisappear_result, layoutRegionMargin: layoutRegionMargin_result, previewAnimationOptions: previewAnimationOptions_result, backgroundColor: backgroundColor_result, backgroundBlurStyle: backgroundBlurStyle_result, backgroundBlurStyleOptions: backgroundBlurStyleOptions_result, backgroundEffect: backgroundEffect_result, transition: transition_result, enableHoverMode: enableHoverMode_result, outlineColor: outlineColor_result, outlineWidth: outlineWidth_result, hapticFeedbackMode: hapticFeedbackMode_result} as ContextMenuOptions)
         return value
     }
 }
-export class SheetOptions_serializer {
-    public static write(buffer: SerializerBase, value: SheetOptions): void {
+export class CustomPopupOptions_serializer {
+    public static write(buffer: SerializerBase, value: CustomPopupOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_backgroundColor  = value.backgroundColor
-        let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundColor_type = runtimeType(value_backgroundColor)
-        valueSerializer.writeInt8((value_backgroundColor_type).toChar())
-        if ((value_backgroundColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundColor_value  = value_backgroundColor!
-            let value_backgroundColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_backgroundColor_value_type = runtimeType(value_backgroundColor_value)
-            if (TypeChecker.isColor(value_backgroundColor_value)) {
+        const value_builder  = value.builder
+        valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_builder))
+        const value_placement  = value.placement
+        let value_placement_type : int32 = RuntimeType.UNDEFINED
+        value_placement_type = runtimeType(value_placement)
+        valueSerializer.writeInt8((value_placement_type).toChar())
+        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
+            const value_placement_value  = (value_placement as Placement)
+            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+        }
+        const value_popupColor  = value.popupColor
+        let value_popupColor_type : int32 = RuntimeType.UNDEFINED
+        value_popupColor_type = runtimeType(value_popupColor)
+        valueSerializer.writeInt8((value_popupColor_type).toChar())
+        if ((value_popupColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_popupColor_value  = value_popupColor!
+            let value_popupColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_popupColor_value_type = runtimeType(value_popupColor_value)
+            if (TypeChecker.isColor(value_popupColor_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_backgroundColor_value_0  = value_backgroundColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_backgroundColor_value_0))
+                const value_popupColor_value_0  = value_popupColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_popupColor_value_0))
             }
-            else if (RuntimeType.NUMBER == value_backgroundColor_value_type) {
+            else if (RuntimeType.STRING == value_popupColor_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_backgroundColor_value_1  = value_backgroundColor_value as number
-                valueSerializer.writeNumber(value_backgroundColor_value_1)
+                const value_popupColor_value_1  = value_popupColor_value as string
+                valueSerializer.writeString(value_popupColor_value_1)
             }
-            else if (RuntimeType.STRING == value_backgroundColor_value_type) {
+            else if (RuntimeType.OBJECT == value_popupColor_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_backgroundColor_value_2  = value_backgroundColor_value as string
-                valueSerializer.writeString(value_backgroundColor_value_2)
+                const value_popupColor_value_2  = value_popupColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_popupColor_value_2)
             }
-            else if (RuntimeType.OBJECT == value_backgroundColor_value_type) {
+            else if (RuntimeType.NUMBER == value_popupColor_value_type) {
                 valueSerializer.writeInt8((3).toChar())
-                const value_backgroundColor_value_3  = value_backgroundColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
+                const value_popupColor_value_3  = value_popupColor_value as number
+                valueSerializer.writeNumber(value_popupColor_value_3)
             }
         }
-        const value_onAppear  = value.onAppear
-        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onAppear_type = runtimeType(value_onAppear)
-        valueSerializer.writeInt8((value_onAppear_type).toChar())
-        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onAppear_value  = value_onAppear!
-            valueSerializer.holdAndWriteCallback(value_onAppear_value)
-        }
-        const value_onDisappear  = value.onDisappear
-        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onDisappear_type = runtimeType(value_onDisappear)
-        valueSerializer.writeInt8((value_onDisappear_type).toChar())
-        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onDisappear_value  = value_onDisappear!
-            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
+        const value_enableArrow  = value.enableArrow
+        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
+        value_enableArrow_type = runtimeType(value_enableArrow)
+        valueSerializer.writeInt8((value_enableArrow_type).toChar())
+        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableArrow_value  = value_enableArrow!
+            valueSerializer.writeBoolean(value_enableArrow_value)
         }
-        const value_onWillAppear  = value.onWillAppear
-        let value_onWillAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onWillAppear_type = runtimeType(value_onWillAppear)
-        valueSerializer.writeInt8((value_onWillAppear_type).toChar())
-        if ((value_onWillAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillAppear_value  = value_onWillAppear!
-            valueSerializer.holdAndWriteCallback(value_onWillAppear_value)
+        const value_autoCancel  = value.autoCancel
+        let value_autoCancel_type : int32 = RuntimeType.UNDEFINED
+        value_autoCancel_type = runtimeType(value_autoCancel)
+        valueSerializer.writeInt8((value_autoCancel_type).toChar())
+        if ((value_autoCancel_type) != (RuntimeType.UNDEFINED)) {
+            const value_autoCancel_value  = value_autoCancel!
+            valueSerializer.writeBoolean(value_autoCancel_value)
         }
-        const value_onWillDisappear  = value.onWillDisappear
-        let value_onWillDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onWillDisappear_type = runtimeType(value_onWillDisappear)
-        valueSerializer.writeInt8((value_onWillDisappear_type).toChar())
-        if ((value_onWillDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillDisappear_value  = value_onWillDisappear!
-            valueSerializer.holdAndWriteCallback(value_onWillDisappear_value)
+        const value_onStateChange  = value.onStateChange
+        let value_onStateChange_type : int32 = RuntimeType.UNDEFINED
+        value_onStateChange_type = runtimeType(value_onStateChange)
+        valueSerializer.writeInt8((value_onStateChange_type).toChar())
+        if ((value_onStateChange_type) != (RuntimeType.UNDEFINED)) {
+            const value_onStateChange_value  = value_onStateChange!
+            valueSerializer.holdAndWriteCallback(value_onStateChange_value)
         }
-        const value_height  = value.height
-        let value_height_type : int32 = RuntimeType.UNDEFINED
-        value_height_type = runtimeType(value_height)
-        valueSerializer.writeInt8((value_height_type).toChar())
-        if ((value_height_type) != (RuntimeType.UNDEFINED)) {
-            const value_height_value  = value_height!
-            let value_height_value_type : int32 = RuntimeType.UNDEFINED
-            value_height_value_type = runtimeType(value_height_value)
-            if (TypeChecker.isSheetSize(value_height_value)) {
+        const value_arrowOffset  = value.arrowOffset
+        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
+        value_arrowOffset_type = runtimeType(value_arrowOffset)
+        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
+        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowOffset_value  = value_arrowOffset!
+            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
+            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
+            if (RuntimeType.STRING == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_height_value_0  = value_height_value as SheetSize
-                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_height_value_0))
+                const value_arrowOffset_value_0  = value_arrowOffset_value as string
+                valueSerializer.writeString(value_arrowOffset_value_0)
             }
-            else if ((RuntimeType.STRING == value_height_value_type) || (RuntimeType.NUMBER == value_height_value_type) || (RuntimeType.OBJECT == value_height_value_type)) {
+            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_height_value_1  = value_height_value as Length
-                let value_height_value_1_type : int32 = RuntimeType.UNDEFINED
-                value_height_value_1_type = runtimeType(value_height_value_1)
-                if (RuntimeType.STRING == value_height_value_1_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_height_value_1_0  = value_height_value_1 as string
-                    valueSerializer.writeString(value_height_value_1_0)
-                }
-                else if (RuntimeType.NUMBER == value_height_value_1_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_height_value_1_1  = value_height_value_1 as number
-                    valueSerializer.writeNumber(value_height_value_1_1)
-                }
-                else if (RuntimeType.OBJECT == value_height_value_1_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_height_value_1_2  = value_height_value_1 as Resource
-                    Resource_serializer.write(valueSerializer, value_height_value_1_2)
-                }
+                const value_arrowOffset_value_1  = value_arrowOffset_value as number
+                valueSerializer.writeNumber(value_arrowOffset_value_1)
+            }
+            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
+                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
             }
         }
-        const value_dragBar  = value.dragBar
-        let value_dragBar_type : int32 = RuntimeType.UNDEFINED
-        value_dragBar_type = runtimeType(value_dragBar)
-        valueSerializer.writeInt8((value_dragBar_type).toChar())
-        if ((value_dragBar_type) != (RuntimeType.UNDEFINED)) {
-            const value_dragBar_value  = value_dragBar!
-            valueSerializer.writeBoolean(value_dragBar_value)
+        const value_showInSubWindow  = value.showInSubWindow
+        let value_showInSubWindow_type : int32 = RuntimeType.UNDEFINED
+        value_showInSubWindow_type = runtimeType(value_showInSubWindow)
+        valueSerializer.writeInt8((value_showInSubWindow_type).toChar())
+        if ((value_showInSubWindow_type) != (RuntimeType.UNDEFINED)) {
+            const value_showInSubWindow_value  = value_showInSubWindow!
+            valueSerializer.writeBoolean(value_showInSubWindow_value)
         }
-        const value_maskColor  = value.maskColor
-        let value_maskColor_type : int32 = RuntimeType.UNDEFINED
-        value_maskColor_type = runtimeType(value_maskColor)
-        valueSerializer.writeInt8((value_maskColor_type).toChar())
-        if ((value_maskColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_maskColor_value  = value_maskColor!
-            let value_maskColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_maskColor_value_type = runtimeType(value_maskColor_value)
-            if (TypeChecker.isColor(value_maskColor_value)) {
+        const value_mask  = value.mask
+        let value_mask_type : int32 = RuntimeType.UNDEFINED
+        value_mask_type = runtimeType(value_mask)
+        valueSerializer.writeInt8((value_mask_type).toChar())
+        if ((value_mask_type) != (RuntimeType.UNDEFINED)) {
+            const value_mask_value  = value_mask!
+            let value_mask_value_type : int32 = RuntimeType.UNDEFINED
+            value_mask_value_type = runtimeType(value_mask_value)
+            if (RuntimeType.BOOLEAN == value_mask_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_maskColor_value_0  = value_maskColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_maskColor_value_0))
+                const value_mask_value_0  = value_mask_value as boolean
+                valueSerializer.writeBoolean(value_mask_value_0)
             }
-            else if (RuntimeType.NUMBER == value_maskColor_value_type) {
+            else if (RuntimeType.OBJECT == value_mask_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_maskColor_value_1  = value_maskColor_value as number
-                valueSerializer.writeNumber(value_maskColor_value_1)
-            }
-            else if (RuntimeType.STRING == value_maskColor_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_maskColor_value_2  = value_maskColor_value as string
-                valueSerializer.writeString(value_maskColor_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_maskColor_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_maskColor_value_3  = value_maskColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_maskColor_value_3)
+                const value_mask_value_1  = value_mask_value as PopupMaskType
+                PopupMaskType_serializer.write(valueSerializer, value_mask_value_1)
             }
         }
-        const value_detents  = value.detents
-        let value_detents_type : int32 = RuntimeType.UNDEFINED
-        value_detents_type = runtimeType(value_detents)
-        valueSerializer.writeInt8((value_detents_type).toChar())
-        if ((value_detents_type) != (RuntimeType.UNDEFINED)) {
-            const value_detents_value  = value_detents!
-            const value_detents_value_0  = value_detents_value[0]
-            let value_detents_value_0_type : int32 = RuntimeType.UNDEFINED
-            value_detents_value_0_type = runtimeType(value_detents_value_0)
-            if (TypeChecker.isSheetSize(value_detents_value_0)) {
+        const value_targetSpace  = value.targetSpace
+        let value_targetSpace_type : int32 = RuntimeType.UNDEFINED
+        value_targetSpace_type = runtimeType(value_targetSpace)
+        valueSerializer.writeInt8((value_targetSpace_type).toChar())
+        if ((value_targetSpace_type) != (RuntimeType.UNDEFINED)) {
+            const value_targetSpace_value  = value_targetSpace!
+            let value_targetSpace_value_type : int32 = RuntimeType.UNDEFINED
+            value_targetSpace_value_type = runtimeType(value_targetSpace_value)
+            if (RuntimeType.STRING == value_targetSpace_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_detents_value_0_0  = value_detents_value_0 as SheetSize
-                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_0_0))
+                const value_targetSpace_value_0  = value_targetSpace_value as string
+                valueSerializer.writeString(value_targetSpace_value_0)
             }
-            else if ((RuntimeType.STRING == value_detents_value_0_type) || (RuntimeType.NUMBER == value_detents_value_0_type) || (RuntimeType.OBJECT == value_detents_value_0_type)) {
+            else if (RuntimeType.NUMBER == value_targetSpace_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_detents_value_0_1  = value_detents_value_0 as Length
-                let value_detents_value_0_1_type : int32 = RuntimeType.UNDEFINED
-                value_detents_value_0_1_type = runtimeType(value_detents_value_0_1)
-                if (RuntimeType.STRING == value_detents_value_0_1_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_detents_value_0_1_0  = value_detents_value_0_1 as string
-                    valueSerializer.writeString(value_detents_value_0_1_0)
-                }
-                else if (RuntimeType.NUMBER == value_detents_value_0_1_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_detents_value_0_1_1  = value_detents_value_0_1 as number
-                    valueSerializer.writeNumber(value_detents_value_0_1_1)
-                }
-                else if (RuntimeType.OBJECT == value_detents_value_0_1_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_detents_value_0_1_2  = value_detents_value_0_1 as Resource
-                    Resource_serializer.write(valueSerializer, value_detents_value_0_1_2)
-                }
+                const value_targetSpace_value_1  = value_targetSpace_value as number
+                valueSerializer.writeNumber(value_targetSpace_value_1)
             }
-            const value_detents_value_1  = value_detents_value[1]
-            let value_detents_value_1_type : int32 = RuntimeType.UNDEFINED
-            value_detents_value_1_type = runtimeType(value_detents_value_1)
-            valueSerializer.writeInt8((value_detents_value_1_type).toChar())
-            if ((value_detents_value_1_type) != (RuntimeType.UNDEFINED)) {
-                const value_detents_value_1_value  = value_detents_value_1!
-                let value_detents_value_1_value_type : int32 = RuntimeType.UNDEFINED
-                value_detents_value_1_value_type = runtimeType(value_detents_value_1_value)
-                if (TypeChecker.isSheetSize(value_detents_value_1_value)) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_detents_value_1_value_0  = value_detents_value_1_value as SheetSize
-                    valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_1_value_0))
-                }
-                else if ((RuntimeType.STRING == value_detents_value_1_value_type) || (RuntimeType.NUMBER == value_detents_value_1_value_type) || (RuntimeType.OBJECT == value_detents_value_1_value_type)) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_detents_value_1_value_1  = value_detents_value_1_value as Length
-                    let value_detents_value_1_value_1_type : int32 = RuntimeType.UNDEFINED
-                    value_detents_value_1_value_1_type = runtimeType(value_detents_value_1_value_1)
-                    if (RuntimeType.STRING == value_detents_value_1_value_1_type) {
-                        valueSerializer.writeInt8((0).toChar())
-                        const value_detents_value_1_value_1_0  = value_detents_value_1_value_1 as string
-                        valueSerializer.writeString(value_detents_value_1_value_1_0)
-                    }
-                    else if (RuntimeType.NUMBER == value_detents_value_1_value_1_type) {
-                        valueSerializer.writeInt8((1).toChar())
-                        const value_detents_value_1_value_1_1  = value_detents_value_1_value_1 as number
-                        valueSerializer.writeNumber(value_detents_value_1_value_1_1)
-                    }
-                    else if (RuntimeType.OBJECT == value_detents_value_1_value_1_type) {
-                        valueSerializer.writeInt8((2).toChar())
-                        const value_detents_value_1_value_1_2  = value_detents_value_1_value_1 as Resource
-                        Resource_serializer.write(valueSerializer, value_detents_value_1_value_1_2)
-                    }
-                }
-            }
-            const value_detents_value_2  = value_detents_value[2]
-            let value_detents_value_2_type : int32 = RuntimeType.UNDEFINED
-            value_detents_value_2_type = runtimeType(value_detents_value_2)
-            valueSerializer.writeInt8((value_detents_value_2_type).toChar())
-            if ((value_detents_value_2_type) != (RuntimeType.UNDEFINED)) {
-                const value_detents_value_2_value  = value_detents_value_2!
-                let value_detents_value_2_value_type : int32 = RuntimeType.UNDEFINED
-                value_detents_value_2_value_type = runtimeType(value_detents_value_2_value)
-                if (TypeChecker.isSheetSize(value_detents_value_2_value)) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_detents_value_2_value_0  = value_detents_value_2_value as SheetSize
-                    valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_2_value_0))
-                }
-                else if ((RuntimeType.STRING == value_detents_value_2_value_type) || (RuntimeType.NUMBER == value_detents_value_2_value_type) || (RuntimeType.OBJECT == value_detents_value_2_value_type)) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_detents_value_2_value_1  = value_detents_value_2_value as Length
-                    let value_detents_value_2_value_1_type : int32 = RuntimeType.UNDEFINED
-                    value_detents_value_2_value_1_type = runtimeType(value_detents_value_2_value_1)
-                    if (RuntimeType.STRING == value_detents_value_2_value_1_type) {
-                        valueSerializer.writeInt8((0).toChar())
-                        const value_detents_value_2_value_1_0  = value_detents_value_2_value_1 as string
-                        valueSerializer.writeString(value_detents_value_2_value_1_0)
-                    }
-                    else if (RuntimeType.NUMBER == value_detents_value_2_value_1_type) {
-                        valueSerializer.writeInt8((1).toChar())
-                        const value_detents_value_2_value_1_1  = value_detents_value_2_value_1 as number
-                        valueSerializer.writeNumber(value_detents_value_2_value_1_1)
-                    }
-                    else if (RuntimeType.OBJECT == value_detents_value_2_value_1_type) {
-                        valueSerializer.writeInt8((2).toChar())
-                        const value_detents_value_2_value_1_2  = value_detents_value_2_value_1 as Resource
-                        Resource_serializer.write(valueSerializer, value_detents_value_2_value_1_2)
-                    }
-                }
-            }
-        }
-        const value_blurStyle  = value.blurStyle
-        let value_blurStyle_type : int32 = RuntimeType.UNDEFINED
-        value_blurStyle_type = runtimeType(value_blurStyle)
-        valueSerializer.writeInt8((value_blurStyle_type).toChar())
-        if ((value_blurStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_blurStyle_value  = (value_blurStyle as BlurStyle)
-            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_blurStyle_value))
-        }
-        const value_showClose  = value.showClose
-        let value_showClose_type : int32 = RuntimeType.UNDEFINED
-        value_showClose_type = runtimeType(value_showClose)
-        valueSerializer.writeInt8((value_showClose_type).toChar())
-        if ((value_showClose_type) != (RuntimeType.UNDEFINED)) {
-            const value_showClose_value  = value_showClose!
-            let value_showClose_value_type : int32 = RuntimeType.UNDEFINED
-            value_showClose_value_type = runtimeType(value_showClose_value)
-            if (RuntimeType.BOOLEAN == value_showClose_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_showClose_value_0  = value_showClose_value as boolean
-                valueSerializer.writeBoolean(value_showClose_value_0)
-            }
-            else if (RuntimeType.OBJECT == value_showClose_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_showClose_value_1  = value_showClose_value as Resource
-                Resource_serializer.write(valueSerializer, value_showClose_value_1)
-            }
-        }
-        const value_preferType  = value.preferType
-        let value_preferType_type : int32 = RuntimeType.UNDEFINED
-        value_preferType_type = runtimeType(value_preferType)
-        valueSerializer.writeInt8((value_preferType_type).toChar())
-        if ((value_preferType_type) != (RuntimeType.UNDEFINED)) {
-            const value_preferType_value  = (value_preferType as SheetType)
-            valueSerializer.writeInt32(TypeChecker.SheetType_ToNumeric(value_preferType_value))
-        }
-        const value_title  = value.title
-        let value_title_type : int32 = RuntimeType.UNDEFINED
-        value_title_type = runtimeType(value_title)
-        valueSerializer.writeInt8((value_title_type).toChar())
-        if ((value_title_type) != (RuntimeType.UNDEFINED)) {
-            const value_title_value  = value_title!
-            let value_title_value_type : int32 = RuntimeType.UNDEFINED
-            value_title_value_type = runtimeType(value_title_value)
-            if (RuntimeType.OBJECT == value_title_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_title_value_0  = value_title_value as SheetTitleOptions
-                SheetTitleOptions_serializer.write(valueSerializer, value_title_value_0)
-            }
-            else if (RuntimeType.FUNCTION == value_title_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_title_value_1  = value_title_value as CustomBuilder
-                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_title_value_1))
+            else if (RuntimeType.OBJECT == value_targetSpace_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_targetSpace_value_2  = value_targetSpace_value as Resource
+                Resource_serializer.write(valueSerializer, value_targetSpace_value_2)
             }
         }
-        const value_shouldDismiss  = value.shouldDismiss
-        let value_shouldDismiss_type : int32 = RuntimeType.UNDEFINED
-        value_shouldDismiss_type = runtimeType(value_shouldDismiss)
-        valueSerializer.writeInt8((value_shouldDismiss_type).toChar())
-        if ((value_shouldDismiss_type) != (RuntimeType.UNDEFINED)) {
-            const value_shouldDismiss_value  = value_shouldDismiss!
-            valueSerializer.holdAndWriteCallback(value_shouldDismiss_value)
-        }
-        const value_onWillDismiss  = value.onWillDismiss
-        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
-        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
-        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
-        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillDismiss_value  = value_onWillDismiss!
-            valueSerializer.holdAndWriteCallback(value_onWillDismiss_value)
-        }
-        const value_onWillSpringBackWhenDismiss  = value.onWillSpringBackWhenDismiss
-        let value_onWillSpringBackWhenDismiss_type : int32 = RuntimeType.UNDEFINED
-        value_onWillSpringBackWhenDismiss_type = runtimeType(value_onWillSpringBackWhenDismiss)
-        valueSerializer.writeInt8((value_onWillSpringBackWhenDismiss_type).toChar())
-        if ((value_onWillSpringBackWhenDismiss_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillSpringBackWhenDismiss_value  = value_onWillSpringBackWhenDismiss!
-            valueSerializer.holdAndWriteCallback(value_onWillSpringBackWhenDismiss_value)
-        }
-        const value_enableOutsideInteractive  = value.enableOutsideInteractive
-        let value_enableOutsideInteractive_type : int32 = RuntimeType.UNDEFINED
-        value_enableOutsideInteractive_type = runtimeType(value_enableOutsideInteractive)
-        valueSerializer.writeInt8((value_enableOutsideInteractive_type).toChar())
-        if ((value_enableOutsideInteractive_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableOutsideInteractive_value  = value_enableOutsideInteractive!
-            valueSerializer.writeBoolean(value_enableOutsideInteractive_value)
+        const value_offset  = value.offset
+        let value_offset_type : int32 = RuntimeType.UNDEFINED
+        value_offset_type = runtimeType(value_offset)
+        valueSerializer.writeInt8((value_offset_type).toChar())
+        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
+            const value_offset_value  = value_offset!
+            Position_serializer.write(valueSerializer, value_offset_value)
         }
         const value_width  = value.width
         let value_width_type : int32 = RuntimeType.UNDEFINED
@@ -20198,108 +20580,84 @@ export class SheetOptions_serializer {
                 Resource_serializer.write(valueSerializer, value_width_value_2)
             }
         }
-        const value_borderWidth  = value.borderWidth
-        let value_borderWidth_type : int32 = RuntimeType.UNDEFINED
-        value_borderWidth_type = runtimeType(value_borderWidth)
-        valueSerializer.writeInt8((value_borderWidth_type).toChar())
-        if ((value_borderWidth_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderWidth_value  = value_borderWidth!
-            let value_borderWidth_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderWidth_value_type = runtimeType(value_borderWidth_value)
-            if ((RuntimeType.STRING == value_borderWidth_value_type) || (RuntimeType.NUMBER == value_borderWidth_value_type) || (RuntimeType.OBJECT == value_borderWidth_value_type)) {
+        const value_arrowPointPosition  = value.arrowPointPosition
+        let value_arrowPointPosition_type : int32 = RuntimeType.UNDEFINED
+        value_arrowPointPosition_type = runtimeType(value_arrowPointPosition)
+        valueSerializer.writeInt8((value_arrowPointPosition_type).toChar())
+        if ((value_arrowPointPosition_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowPointPosition_value  = (value_arrowPointPosition as ArrowPointPosition)
+            valueSerializer.writeInt32(TypeChecker.ArrowPointPosition_ToNumeric(value_arrowPointPosition_value))
+        }
+        const value_arrowWidth  = value.arrowWidth
+        let value_arrowWidth_type : int32 = RuntimeType.UNDEFINED
+        value_arrowWidth_type = runtimeType(value_arrowWidth)
+        valueSerializer.writeInt8((value_arrowWidth_type).toChar())
+        if ((value_arrowWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowWidth_value  = value_arrowWidth!
+            let value_arrowWidth_value_type : int32 = RuntimeType.UNDEFINED
+            value_arrowWidth_value_type = runtimeType(value_arrowWidth_value)
+            if (RuntimeType.STRING == value_arrowWidth_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_borderWidth_value_0  = value_borderWidth_value as Dimension
-                let value_borderWidth_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_borderWidth_value_0_type = runtimeType(value_borderWidth_value_0)
-                if (RuntimeType.STRING == value_borderWidth_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_borderWidth_value_0_0  = value_borderWidth_value_0 as string
-                    valueSerializer.writeString(value_borderWidth_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_borderWidth_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_borderWidth_value_0_1  = value_borderWidth_value_0 as number
-                    valueSerializer.writeNumber(value_borderWidth_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_borderWidth_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_borderWidth_value_0_2  = value_borderWidth_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_borderWidth_value_0_2)
-                }
+                const value_arrowWidth_value_0  = value_arrowWidth_value as string
+                valueSerializer.writeString(value_arrowWidth_value_0)
             }
-            else if (TypeChecker.isEdgeWidths(value_borderWidth_value, true, false, true, false)) {
+            else if (RuntimeType.NUMBER == value_arrowWidth_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_borderWidth_value_1  = value_borderWidth_value as EdgeWidths
-                EdgeWidths_serializer.write(valueSerializer, value_borderWidth_value_1)
+                const value_arrowWidth_value_1  = value_arrowWidth_value as number
+                valueSerializer.writeNumber(value_arrowWidth_value_1)
             }
-            else if (TypeChecker.isLocalizedEdgeWidths(value_borderWidth_value, true, false, true, false)) {
+            else if (RuntimeType.OBJECT == value_arrowWidth_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_borderWidth_value_2  = value_borderWidth_value as LocalizedEdgeWidths
-                LocalizedEdgeWidths_serializer.write(valueSerializer, value_borderWidth_value_2)
+                const value_arrowWidth_value_2  = value_arrowWidth_value as Resource
+                Resource_serializer.write(valueSerializer, value_arrowWidth_value_2)
             }
         }
-        const value_borderColor  = value.borderColor
-        let value_borderColor_type : int32 = RuntimeType.UNDEFINED
-        value_borderColor_type = runtimeType(value_borderColor)
-        valueSerializer.writeInt8((value_borderColor_type).toChar())
-        if ((value_borderColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderColor_value  = value_borderColor!
-            let value_borderColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderColor_value_type = runtimeType(value_borderColor_value)
-            if ((TypeChecker.isColor(value_borderColor_value)) || (RuntimeType.NUMBER == value_borderColor_value_type) || (RuntimeType.STRING == value_borderColor_value_type) || (RuntimeType.OBJECT == value_borderColor_value_type)) {
+        const value_arrowHeight  = value.arrowHeight
+        let value_arrowHeight_type : int32 = RuntimeType.UNDEFINED
+        value_arrowHeight_type = runtimeType(value_arrowHeight)
+        valueSerializer.writeInt8((value_arrowHeight_type).toChar())
+        if ((value_arrowHeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowHeight_value  = value_arrowHeight!
+            let value_arrowHeight_value_type : int32 = RuntimeType.UNDEFINED
+            value_arrowHeight_value_type = runtimeType(value_arrowHeight_value)
+            if (RuntimeType.STRING == value_arrowHeight_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_borderColor_value_0  = value_borderColor_value as ResourceColor
-                let value_borderColor_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_borderColor_value_0_type = runtimeType(value_borderColor_value_0)
-                if (TypeChecker.isColor(value_borderColor_value_0)) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_borderColor_value_0_0  = value_borderColor_value_0 as Color
-                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_borderColor_value_0_0))
-                }
-                else if (RuntimeType.NUMBER == value_borderColor_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_borderColor_value_0_1  = value_borderColor_value_0 as number
-                    valueSerializer.writeNumber(value_borderColor_value_0_1)
-                }
-                else if (RuntimeType.STRING == value_borderColor_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_borderColor_value_0_2  = value_borderColor_value_0 as string
-                    valueSerializer.writeString(value_borderColor_value_0_2)
-                }
-                else if (RuntimeType.OBJECT == value_borderColor_value_0_type) {
-                    valueSerializer.writeInt8((3).toChar())
-                    const value_borderColor_value_0_3  = value_borderColor_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_borderColor_value_0_3)
-                }
+                const value_arrowHeight_value_0  = value_arrowHeight_value as string
+                valueSerializer.writeString(value_arrowHeight_value_0)
             }
-            else if (TypeChecker.isEdgeColors(value_borderColor_value, true, false, true, false)) {
+            else if (RuntimeType.NUMBER == value_arrowHeight_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_borderColor_value_1  = value_borderColor_value as EdgeColors
-                EdgeColors_serializer.write(valueSerializer, value_borderColor_value_1)
+                const value_arrowHeight_value_1  = value_arrowHeight_value as number
+                valueSerializer.writeNumber(value_arrowHeight_value_1)
             }
-            else if (TypeChecker.isLocalizedEdgeColors(value_borderColor_value, true, false, true, false)) {
+            else if (RuntimeType.OBJECT == value_arrowHeight_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_borderColor_value_2  = value_borderColor_value as LocalizedEdgeColors
-                LocalizedEdgeColors_serializer.write(valueSerializer, value_borderColor_value_2)
+                const value_arrowHeight_value_2  = value_arrowHeight_value as Resource
+                Resource_serializer.write(valueSerializer, value_arrowHeight_value_2)
             }
         }
-        const value_borderStyle  = value.borderStyle
-        let value_borderStyle_type : int32 = RuntimeType.UNDEFINED
-        value_borderStyle_type = runtimeType(value_borderStyle)
-        valueSerializer.writeInt8((value_borderStyle_type).toChar())
-        if ((value_borderStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderStyle_value  = value_borderStyle!
-            let value_borderStyle_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderStyle_value_type = runtimeType(value_borderStyle_value)
-            if (TypeChecker.isBorderStyle(value_borderStyle_value)) {
+        const value_radius  = value.radius
+        let value_radius_type : int32 = RuntimeType.UNDEFINED
+        value_radius_type = runtimeType(value_radius)
+        valueSerializer.writeInt8((value_radius_type).toChar())
+        if ((value_radius_type) != (RuntimeType.UNDEFINED)) {
+            const value_radius_value  = value_radius!
+            let value_radius_value_type : int32 = RuntimeType.UNDEFINED
+            value_radius_value_type = runtimeType(value_radius_value)
+            if (RuntimeType.STRING == value_radius_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_borderStyle_value_0  = value_borderStyle_value as BorderStyle
-                valueSerializer.writeInt32(TypeChecker.BorderStyle_ToNumeric(value_borderStyle_value_0))
+                const value_radius_value_0  = value_radius_value as string
+                valueSerializer.writeString(value_radius_value_0)
             }
-            else if (RuntimeType.OBJECT == value_borderStyle_value_type) {
+            else if (RuntimeType.NUMBER == value_radius_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_borderStyle_value_1  = value_borderStyle_value as EdgeStyles
-                EdgeStyles_serializer.write(valueSerializer, value_borderStyle_value_1)
+                const value_radius_value_1  = value_radius_value as number
+                valueSerializer.writeNumber(value_radius_value_1)
+            }
+            else if (RuntimeType.OBJECT == value_radius_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_radius_value_2  = value_radius_value as Resource
+                Resource_serializer.write(valueSerializer, value_radius_value_2)
             }
         }
         const value_shadow  = value.shadow
@@ -20321,69 +20679,48 @@ export class SheetOptions_serializer {
                 valueSerializer.writeInt32(TypeChecker.ShadowStyle_ToNumeric(value_shadow_value_1))
             }
         }
-        const value_onHeightDidChange  = value.onHeightDidChange
-        let value_onHeightDidChange_type : int32 = RuntimeType.UNDEFINED
-        value_onHeightDidChange_type = runtimeType(value_onHeightDidChange)
-        valueSerializer.writeInt8((value_onHeightDidChange_type).toChar())
-        if ((value_onHeightDidChange_type) != (RuntimeType.UNDEFINED)) {
-            const value_onHeightDidChange_value  = value_onHeightDidChange!
-            valueSerializer.holdAndWriteCallback(value_onHeightDidChange_value)
-        }
-        const value_mode  = value.mode
-        let value_mode_type : int32 = RuntimeType.UNDEFINED
-        value_mode_type = runtimeType(value_mode)
-        valueSerializer.writeInt8((value_mode_type).toChar())
-        if ((value_mode_type) != (RuntimeType.UNDEFINED)) {
-            const value_mode_value  = (value_mode as SheetMode)
-            valueSerializer.writeInt32(TypeChecker.SheetMode_ToNumeric(value_mode_value))
-        }
-        const value_scrollSizeMode  = value.scrollSizeMode
-        let value_scrollSizeMode_type : int32 = RuntimeType.UNDEFINED
-        value_scrollSizeMode_type = runtimeType(value_scrollSizeMode)
-        valueSerializer.writeInt8((value_scrollSizeMode_type).toChar())
-        if ((value_scrollSizeMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_scrollSizeMode_value  = (value_scrollSizeMode as ScrollSizeMode)
-            valueSerializer.writeInt32(TypeChecker.ScrollSizeMode_ToNumeric(value_scrollSizeMode_value))
-        }
-        const value_onDetentsDidChange  = value.onDetentsDidChange
-        let value_onDetentsDidChange_type : int32 = RuntimeType.UNDEFINED
-        value_onDetentsDidChange_type = runtimeType(value_onDetentsDidChange)
-        valueSerializer.writeInt8((value_onDetentsDidChange_type).toChar())
-        if ((value_onDetentsDidChange_type) != (RuntimeType.UNDEFINED)) {
-            const value_onDetentsDidChange_value  = value_onDetentsDidChange!
-            valueSerializer.holdAndWriteCallback(value_onDetentsDidChange_value)
-        }
-        const value_onWidthDidChange  = value.onWidthDidChange
-        let value_onWidthDidChange_type : int32 = RuntimeType.UNDEFINED
-        value_onWidthDidChange_type = runtimeType(value_onWidthDidChange)
-        valueSerializer.writeInt8((value_onWidthDidChange_type).toChar())
-        if ((value_onWidthDidChange_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWidthDidChange_value  = value_onWidthDidChange!
-            valueSerializer.holdAndWriteCallback(value_onWidthDidChange_value)
+        const value_backgroundBlurStyle  = value.backgroundBlurStyle
+        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
+        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
+        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
+            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
         }
-        const value_onTypeDidChange  = value.onTypeDidChange
-        let value_onTypeDidChange_type : int32 = RuntimeType.UNDEFINED
-        value_onTypeDidChange_type = runtimeType(value_onTypeDidChange)
-        valueSerializer.writeInt8((value_onTypeDidChange_type).toChar())
-        if ((value_onTypeDidChange_type) != (RuntimeType.UNDEFINED)) {
-            const value_onTypeDidChange_value  = value_onTypeDidChange!
-            valueSerializer.holdAndWriteCallback(value_onTypeDidChange_value)
+        const value_focusable  = value.focusable
+        let value_focusable_type : int32 = RuntimeType.UNDEFINED
+        value_focusable_type = runtimeType(value_focusable)
+        valueSerializer.writeInt8((value_focusable_type).toChar())
+        if ((value_focusable_type) != (RuntimeType.UNDEFINED)) {
+            const value_focusable_value  = value_focusable!
+            valueSerializer.writeBoolean(value_focusable_value)
         }
-        const value_uiContext  = value.uiContext
-        let value_uiContext_type : int32 = RuntimeType.UNDEFINED
-        value_uiContext_type = runtimeType(value_uiContext)
-        valueSerializer.writeInt8((value_uiContext_type).toChar())
-        if ((value_uiContext_type) != (RuntimeType.UNDEFINED)) {
-            const value_uiContext_value  = value_uiContext!
-            UIContext_serializer.write(valueSerializer, value_uiContext_value)
+        const value_transition  = value.transition
+        let value_transition_type : int32 = RuntimeType.UNDEFINED
+        value_transition_type = runtimeType(value_transition)
+        valueSerializer.writeInt8((value_transition_type).toChar())
+        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
+            const value_transition_value  = value_transition!
+            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
         }
-        const value_keyboardAvoidMode  = value.keyboardAvoidMode
-        let value_keyboardAvoidMode_type : int32 = RuntimeType.UNDEFINED
-        value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode)
-        valueSerializer.writeInt8((value_keyboardAvoidMode_type).toChar())
-        if ((value_keyboardAvoidMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_keyboardAvoidMode_value  = (value_keyboardAvoidMode as SheetKeyboardAvoidMode)
-            valueSerializer.writeInt32(TypeChecker.SheetKeyboardAvoidMode_ToNumeric(value_keyboardAvoidMode_value))
+        const value_onWillDismiss  = value.onWillDismiss
+        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
+        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
+        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
+        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillDismiss_value  = value_onWillDismiss!
+            let value_onWillDismiss_value_type : int32 = RuntimeType.UNDEFINED
+            value_onWillDismiss_value_type = runtimeType(value_onWillDismiss_value)
+            if (RuntimeType.BOOLEAN == value_onWillDismiss_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_onWillDismiss_value_0  = value_onWillDismiss_value as boolean
+                valueSerializer.writeBoolean(value_onWillDismiss_value_0)
+            }
+            else if (RuntimeType.FUNCTION == value_onWillDismiss_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_onWillDismiss_value_1  = value_onWillDismiss_value as ((value0: DismissPopupAction) => void)
+                valueSerializer.holdAndWriteCallback(value_onWillDismiss_value_1)
+            }
         }
         const value_enableHoverMode  = value.enableHoverMode
         let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
@@ -20393,489 +20730,173 @@ export class SheetOptions_serializer {
             const value_enableHoverMode_value  = value_enableHoverMode!
             valueSerializer.writeBoolean(value_enableHoverMode_value)
         }
-        const value_hoverModeArea  = value.hoverModeArea
-        let value_hoverModeArea_type : int32 = RuntimeType.UNDEFINED
-        value_hoverModeArea_type = runtimeType(value_hoverModeArea)
-        valueSerializer.writeInt8((value_hoverModeArea_type).toChar())
-        if ((value_hoverModeArea_type) != (RuntimeType.UNDEFINED)) {
-            const value_hoverModeArea_value  = (value_hoverModeArea as HoverModeAreaType)
-            valueSerializer.writeInt32(TypeChecker.HoverModeAreaType_ToNumeric(value_hoverModeArea_value))
+        const value_followTransformOfTarget  = value.followTransformOfTarget
+        let value_followTransformOfTarget_type : int32 = RuntimeType.UNDEFINED
+        value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget)
+        valueSerializer.writeInt8((value_followTransformOfTarget_type).toChar())
+        if ((value_followTransformOfTarget_type) != (RuntimeType.UNDEFINED)) {
+            const value_followTransformOfTarget_value  = value_followTransformOfTarget!
+            valueSerializer.writeBoolean(value_followTransformOfTarget_value)
         }
-        const value_offset  = value.offset
-        let value_offset_type : int32 = RuntimeType.UNDEFINED
-        value_offset_type = runtimeType(value_offset)
-        valueSerializer.writeInt8((value_offset_type).toChar())
-        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
-            const value_offset_value  = value_offset!
-            Position_serializer.write(valueSerializer, value_offset_value)
+        const value_keyboardAvoidMode  = value.keyboardAvoidMode
+        let value_keyboardAvoidMode_type : int32 = RuntimeType.UNDEFINED
+        value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode)
+        valueSerializer.writeInt8((value_keyboardAvoidMode_type).toChar())
+        if ((value_keyboardAvoidMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_keyboardAvoidMode_value  = (value_keyboardAvoidMode as KeyboardAvoidMode)
+            valueSerializer.writeInt32(TypeChecker.KeyboardAvoidMode_ToNumeric(value_keyboardAvoidMode_value))
         }
-        const value_effectEdge  = value.effectEdge
-        let value_effectEdge_type : int32 = RuntimeType.UNDEFINED
-        value_effectEdge_type = runtimeType(value_effectEdge)
-        valueSerializer.writeInt8((value_effectEdge_type).toChar())
-        if ((value_effectEdge_type) != (RuntimeType.UNDEFINED)) {
-            const value_effectEdge_value  = value_effectEdge!
-            valueSerializer.writeNumber(value_effectEdge_value)
+    }
+    public static read(buffer: DeserializerBase): CustomPopupOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const builder_buf_resource : CallbackResource = valueDeserializer.readCallbackResource()
+        const builder_buf_call : KPointer = valueDeserializer.readPointer()
+        const builder_buf_callSync : KPointer = valueDeserializer.readPointer()
+        const builder_result : CustomBuilder = ():void => { 
+    const builder_buf_argsSerializer : SerializerBase = SerializerBase.hold();
+    builder_buf_argsSerializer.writeInt32(builder_buf_resource.resourceId);
+    builder_buf_argsSerializer.writePointer(builder_buf_call);
+    builder_buf_argsSerializer.writePointer(builder_buf_callSync);
+    InteropNativeModule._CallCallback(737226752, builder_buf_argsSerializer.asBuffer(), builder_buf_argsSerializer.length());
+    builder_buf_argsSerializer.release();
+    return; }
+        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let placement_buf : Placement | undefined
+        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
         }
-        const value_radius  = value.radius
-        let value_radius_type : int32 = RuntimeType.UNDEFINED
-        value_radius_type = runtimeType(value_radius)
-        valueSerializer.writeInt8((value_radius_type).toChar())
-        if ((value_radius_type) != (RuntimeType.UNDEFINED)) {
-            const value_radius_value  = value_radius!
-            let value_radius_value_type : int32 = RuntimeType.UNDEFINED
-            value_radius_value_type = runtimeType(value_radius_value)
-            if (TypeChecker.isLengthMetrics(value_radius_value, false, false)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_radius_value_0  = value_radius_value as LengthMetrics
-                LengthMetrics_serializer.write(valueSerializer, value_radius_value_0)
+        const placement_result : Placement | undefined = placement_buf
+        const popupColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let popupColor_buf : Color | string | Resource | number | undefined
+        if ((popupColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const popupColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let popupColor_buf_ : Color | string | Resource | number | undefined
+            if (popupColor_buf__selector == (0).toChar()) {
+                popupColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (TypeChecker.isBorderRadiuses(value_radius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_radius_value_1  = value_radius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_radius_value_1)
+            else if (popupColor_buf__selector == (1).toChar()) {
+                popupColor_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (TypeChecker.isLocalizedBorderRadiuses(value_radius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_radius_value_2  = value_radius_value as LocalizedBorderRadiuses
-                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_radius_value_2)
+            else if (popupColor_buf__selector == (2).toChar()) {
+                popupColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
-        }
-        const value_detentSelection  = value.detentSelection
-        let value_detentSelection_type : int32 = RuntimeType.UNDEFINED
-        value_detentSelection_type = runtimeType(value_detentSelection)
-        valueSerializer.writeInt8((value_detentSelection_type).toChar())
-        if ((value_detentSelection_type) != (RuntimeType.UNDEFINED)) {
-            const value_detentSelection_value  = value_detentSelection!
-            let value_detentSelection_value_type : int32 = RuntimeType.UNDEFINED
-            value_detentSelection_value_type = runtimeType(value_detentSelection_value)
-            if (TypeChecker.isSheetSize(value_detentSelection_value)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_detentSelection_value_0  = value_detentSelection_value as SheetSize
-                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detentSelection_value_0))
+            else if (popupColor_buf__selector == (3).toChar()) {
+                popupColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if ((RuntimeType.STRING == value_detentSelection_value_type) || (RuntimeType.NUMBER == value_detentSelection_value_type) || (RuntimeType.OBJECT == value_detentSelection_value_type)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_detentSelection_value_1  = value_detentSelection_value as Length
-                let value_detentSelection_value_1_type : int32 = RuntimeType.UNDEFINED
-                value_detentSelection_value_1_type = runtimeType(value_detentSelection_value_1)
-                if (RuntimeType.STRING == value_detentSelection_value_1_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_detentSelection_value_1_0  = value_detentSelection_value_1 as string
-                    valueSerializer.writeString(value_detentSelection_value_1_0)
-                }
-                else if (RuntimeType.NUMBER == value_detentSelection_value_1_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_detentSelection_value_1_1  = value_detentSelection_value_1 as number
-                    valueSerializer.writeNumber(value_detentSelection_value_1_1)
-                }
-                else if (RuntimeType.OBJECT == value_detentSelection_value_1_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_detentSelection_value_1_2  = value_detentSelection_value_1 as Resource
-                    Resource_serializer.write(valueSerializer, value_detentSelection_value_1_2)
-                }
+            else {
+                throw new Error("One of the branches for popupColor_buf_ has to be chosen through deserialisation.")
             }
+            popupColor_buf = (popupColor_buf_ as Color | string | Resource | number)
         }
-        const value_showInSubWindow  = value.showInSubWindow
-        let value_showInSubWindow_type : int32 = RuntimeType.UNDEFINED
-        value_showInSubWindow_type = runtimeType(value_showInSubWindow)
-        valueSerializer.writeInt8((value_showInSubWindow_type).toChar())
-        if ((value_showInSubWindow_type) != (RuntimeType.UNDEFINED)) {
-            const value_showInSubWindow_value  = value_showInSubWindow!
-            valueSerializer.writeBoolean(value_showInSubWindow_value)
+        const popupColor_result : Color | string | Resource | number | undefined = popupColor_buf
+        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableArrow_buf : boolean | undefined
+        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            enableArrow_buf = valueDeserializer.readBoolean()
         }
-        const value_placement  = value.placement
-        let value_placement_type : int32 = RuntimeType.UNDEFINED
-        value_placement_type = runtimeType(value_placement)
-        valueSerializer.writeInt8((value_placement_type).toChar())
-        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
-            const value_placement_value  = (value_placement as Placement)
-            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+        const enableArrow_result : boolean | undefined = enableArrow_buf
+        const autoCancel_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let autoCancel_buf : boolean | undefined
+        if ((autoCancel_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            autoCancel_buf = valueDeserializer.readBoolean()
         }
-        const value_placementOnTarget  = value.placementOnTarget
-        let value_placementOnTarget_type : int32 = RuntimeType.UNDEFINED
-        value_placementOnTarget_type = runtimeType(value_placementOnTarget)
-        valueSerializer.writeInt8((value_placementOnTarget_type).toChar())
-        if ((value_placementOnTarget_type) != (RuntimeType.UNDEFINED)) {
-            const value_placementOnTarget_value  = value_placementOnTarget!
-            valueSerializer.writeBoolean(value_placementOnTarget_value)
+        const autoCancel_result : boolean | undefined = autoCancel_buf
+        const onStateChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onStateChange_buf : PopupStateChangeCallback | undefined
+        if ((onStateChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onStateChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onStateChange_buf__call : KPointer = valueDeserializer.readPointer()
+            const onStateChange_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onStateChange_buf = (event: PopupStateChangeParam):void => { 
+    const onStateChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onStateChange_buf__argsSerializer.writeInt32(onStateChange_buf__resource.resourceId);
+    onStateChange_buf__argsSerializer.writePointer(onStateChange_buf__call);
+    onStateChange_buf__argsSerializer.writePointer(onStateChange_buf__callSync);
+    PopupStateChangeParam_serializer.write(onStateChange_buf__argsSerializer, event);
+    InteropNativeModule._CallCallback(-1444325632, onStateChange_buf__argsSerializer.asBuffer(), onStateChange_buf__argsSerializer.length());
+    onStateChange_buf__argsSerializer.release();
+    return; }
         }
-    }
-    public static read(buffer: DeserializerBase): SheetOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundColor_buf : ResourceColor | undefined
-        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const onStateChange_result : PopupStateChangeCallback | undefined = onStateChange_buf
+        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowOffset_buf : Length | undefined
+        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let backgroundColor_buf_ : Color | number | string | Resource | undefined
-            if (backgroundColor_buf__selector == (0).toChar()) {
-                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (backgroundColor_buf__selector == (1).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
+            let arrowOffset_buf_ : string | number | Resource | undefined
+            if (arrowOffset_buf__selector == (0).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (backgroundColor_buf__selector == (2).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readString() as string)
+            else if (arrowOffset_buf__selector == (1).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (backgroundColor_buf__selector == (3).toChar()) {
-                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (arrowOffset_buf__selector == (2).toChar()) {
+                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
             }
-            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
-        }
-        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
-        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onAppear_buf : (() => void) | undefined
-        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onAppear_buf = ():void => { 
-    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
-    onAppear_buf__argsSerializer.release();
-    return; }
-        }
-        const onAppear_result : (() => void) | undefined = onAppear_buf
-        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onDisappear_buf : (() => void) | undefined
-        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onDisappear_buf = ():void => { 
-    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
-    onDisappear_buf__argsSerializer.release();
-    return; }
-        }
-        const onDisappear_result : (() => void) | undefined = onDisappear_buf
-        const onWillAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillAppear_buf : (() => void) | undefined
-        if ((onWillAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onWillAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillAppear_buf = ():void => { 
-    const onWillAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillAppear_buf__argsSerializer.writeInt32(onWillAppear_buf__resource.resourceId);
-    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__call);
-    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onWillAppear_buf__argsSerializer.asBuffer(), onWillAppear_buf__argsSerializer.length());
-    onWillAppear_buf__argsSerializer.release();
-    return; }
+            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
         }
-        const onWillAppear_result : (() => void) | undefined = onWillAppear_buf
-        const onWillDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillDisappear_buf : (() => void) | undefined
-        if ((onWillDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const arrowOffset_result : Length | undefined = arrowOffset_buf
+        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let showInSubWindow_buf : boolean | undefined
+        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWillDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillDisappear_buf = ():void => { 
-    const onWillDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillDisappear_buf__argsSerializer.writeInt32(onWillDisappear_buf__resource.resourceId);
-    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__call);
-    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onWillDisappear_buf__argsSerializer.asBuffer(), onWillDisappear_buf__argsSerializer.length());
-    onWillDisappear_buf__argsSerializer.release();
-    return; }
+            showInSubWindow_buf = valueDeserializer.readBoolean()
         }
-        const onWillDisappear_result : (() => void) | undefined = onWillDisappear_buf
-        const height_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let height_buf : SheetSize | Length | undefined
-        if ((height_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
+        const mask_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let mask_buf : boolean | PopupMaskType | undefined
+        if ((mask_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const height_buf__selector : int32 = valueDeserializer.readInt8()
-            let height_buf_ : SheetSize | Length | undefined
-            if (height_buf__selector == (0).toChar()) {
-                height_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
+            const mask_buf__selector : int32 = valueDeserializer.readInt8()
+            let mask_buf_ : boolean | PopupMaskType | undefined
+            if (mask_buf__selector == (0).toChar()) {
+                mask_buf_ = valueDeserializer.readBoolean()
             }
-            else if (height_buf__selector == (1).toChar()) {
-                const height_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let height_buf__u : string | number | Resource | undefined
-                if (height_buf__u_selector == (0).toChar()) {
-                    height_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (height_buf__u_selector == (1).toChar()) {
-                    height_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (height_buf__u_selector == (2).toChar()) {
-                    height_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for height_buf__u has to be chosen through deserialisation.")
-                }
-                height_buf_ = (height_buf__u as string | number | Resource)
+            else if (mask_buf__selector == (1).toChar()) {
+                mask_buf_ = PopupMaskType_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for height_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for mask_buf_ has to be chosen through deserialisation.")
             }
-            height_buf = (height_buf_ as SheetSize | Length)
-        }
-        const height_result : SheetSize | Length | undefined = height_buf
-        const dragBar_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let dragBar_buf : boolean | undefined
-        if ((dragBar_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            dragBar_buf = valueDeserializer.readBoolean()
+            mask_buf = (mask_buf_ as boolean | PopupMaskType)
         }
-        const dragBar_result : boolean | undefined = dragBar_buf
-        const maskColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let maskColor_buf : ResourceColor | undefined
-        if ((maskColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const mask_result : boolean | PopupMaskType | undefined = mask_buf
+        const targetSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let targetSpace_buf : Length | undefined
+        if ((targetSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const maskColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let maskColor_buf_ : Color | number | string | Resource | undefined
-            if (maskColor_buf__selector == (0).toChar()) {
-                maskColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (maskColor_buf__selector == (1).toChar()) {
-                maskColor_buf_ = (valueDeserializer.readNumber() as number)
+            const targetSpace_buf__selector : int32 = valueDeserializer.readInt8()
+            let targetSpace_buf_ : string | number | Resource | undefined
+            if (targetSpace_buf__selector == (0).toChar()) {
+                targetSpace_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (maskColor_buf__selector == (2).toChar()) {
-                maskColor_buf_ = (valueDeserializer.readString() as string)
+            else if (targetSpace_buf__selector == (1).toChar()) {
+                targetSpace_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (maskColor_buf__selector == (3).toChar()) {
-                maskColor_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (targetSpace_buf__selector == (2).toChar()) {
+                targetSpace_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for maskColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.")
             }
-            maskColor_buf = (maskColor_buf_ as Color | number | string | Resource)
+            targetSpace_buf = (targetSpace_buf_ as string | number | Resource)
         }
-        const maskColor_result : ResourceColor | undefined = maskColor_buf
-        const detents_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let detents_buf : TripleLengthDetents | undefined
-        if ((detents_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const targetSpace_result : Length | undefined = targetSpace_buf
+        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offset_buf : Position | undefined
+        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const detents_buf__value0_buf_selector : int32 = valueDeserializer.readInt8()
-            let detents_buf__value0_buf : SheetSize | Length | undefined
-            if (detents_buf__value0_buf_selector == (0).toChar()) {
-                detents_buf__value0_buf = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (detents_buf__value0_buf_selector == (1).toChar()) {
-                const detents_buf__value0_buf_u_selector : int32 = valueDeserializer.readInt8()
-                let detents_buf__value0_buf_u : string | number | Resource | undefined
-                if (detents_buf__value0_buf_u_selector == (0).toChar()) {
-                    detents_buf__value0_buf_u = (valueDeserializer.readString() as string)
-                }
-                else if (detents_buf__value0_buf_u_selector == (1).toChar()) {
-                    detents_buf__value0_buf_u = (valueDeserializer.readNumber() as number)
-                }
-                else if (detents_buf__value0_buf_u_selector == (2).toChar()) {
-                    detents_buf__value0_buf_u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for detents_buf__value0_buf_u has to be chosen through deserialisation.")
-                }
-                detents_buf__value0_buf = (detents_buf__value0_buf_u as string | number | Resource)
-            }
-            else {
-                throw new Error("One of the branches for detents_buf__value0_buf has to be chosen through deserialisation.")
-            }
-            const detents_buf__value0 : SheetSize | Length = (detents_buf__value0_buf as SheetSize | Length)
-            const detents_buf__value1_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-            let detents_buf__value1_buf : SheetSize | Length | undefined
-            if ((detents_buf__value1_buf_runtimeType) != (RuntimeType.UNDEFINED))
-            {
-                const detents_buf__value1_buf__selector : int32 = valueDeserializer.readInt8()
-                let detents_buf__value1_buf_ : SheetSize | Length | undefined
-                if (detents_buf__value1_buf__selector == (0).toChar()) {
-                    detents_buf__value1_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
-                }
-                else if (detents_buf__value1_buf__selector == (1).toChar()) {
-                    const detents_buf__value1_buf__u_selector : int32 = valueDeserializer.readInt8()
-                    let detents_buf__value1_buf__u : string | number | Resource | undefined
-                    if (detents_buf__value1_buf__u_selector == (0).toChar()) {
-                        detents_buf__value1_buf__u = (valueDeserializer.readString() as string)
-                    }
-                    else if (detents_buf__value1_buf__u_selector == (1).toChar()) {
-                        detents_buf__value1_buf__u = (valueDeserializer.readNumber() as number)
-                    }
-                    else if (detents_buf__value1_buf__u_selector == (2).toChar()) {
-                        detents_buf__value1_buf__u = Resource_serializer.read(valueDeserializer)
-                    }
-                    else {
-                        throw new Error("One of the branches for detents_buf__value1_buf__u has to be chosen through deserialisation.")
-                    }
-                    detents_buf__value1_buf_ = (detents_buf__value1_buf__u as string | number | Resource)
-                }
-                else {
-                    throw new Error("One of the branches for detents_buf__value1_buf_ has to be chosen through deserialisation.")
-                }
-                detents_buf__value1_buf = (detents_buf__value1_buf_ as SheetSize | Length)
-            }
-            const detents_buf__value1 : SheetSize | Length | undefined = detents_buf__value1_buf
-            const detents_buf__value2_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-            let detents_buf__value2_buf : SheetSize | Length | undefined
-            if ((detents_buf__value2_buf_runtimeType) != (RuntimeType.UNDEFINED))
-            {
-                const detents_buf__value2_buf__selector : int32 = valueDeserializer.readInt8()
-                let detents_buf__value2_buf_ : SheetSize | Length | undefined
-                if (detents_buf__value2_buf__selector == (0).toChar()) {
-                    detents_buf__value2_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
-                }
-                else if (detents_buf__value2_buf__selector == (1).toChar()) {
-                    const detents_buf__value2_buf__u_selector : int32 = valueDeserializer.readInt8()
-                    let detents_buf__value2_buf__u : string | number | Resource | undefined
-                    if (detents_buf__value2_buf__u_selector == (0).toChar()) {
-                        detents_buf__value2_buf__u = (valueDeserializer.readString() as string)
-                    }
-                    else if (detents_buf__value2_buf__u_selector == (1).toChar()) {
-                        detents_buf__value2_buf__u = (valueDeserializer.readNumber() as number)
-                    }
-                    else if (detents_buf__value2_buf__u_selector == (2).toChar()) {
-                        detents_buf__value2_buf__u = Resource_serializer.read(valueDeserializer)
-                    }
-                    else {
-                        throw new Error("One of the branches for detents_buf__value2_buf__u has to be chosen through deserialisation.")
-                    }
-                    detents_buf__value2_buf_ = (detents_buf__value2_buf__u as string | number | Resource)
-                }
-                else {
-                    throw new Error("One of the branches for detents_buf__value2_buf_ has to be chosen through deserialisation.")
-                }
-                detents_buf__value2_buf = (detents_buf__value2_buf_ as SheetSize | Length)
-            }
-            const detents_buf__value2 : SheetSize | Length | undefined = detents_buf__value2_buf
-            detents_buf = ([detents_buf__value0, detents_buf__value1, detents_buf__value2] as TripleLengthDetents)
-        }
-        const detents_result : TripleLengthDetents | undefined = detents_buf
-        const blurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let blurStyle_buf : BlurStyle | undefined
-        if ((blurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            blurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
-        }
-        const blurStyle_result : BlurStyle | undefined = blurStyle_buf
-        const showClose_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let showClose_buf : boolean | Resource | undefined
-        if ((showClose_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const showClose_buf__selector : int32 = valueDeserializer.readInt8()
-            let showClose_buf_ : boolean | Resource | undefined
-            if (showClose_buf__selector == (0).toChar()) {
-                showClose_buf_ = valueDeserializer.readBoolean()
-            }
-            else if (showClose_buf__selector == (1).toChar()) {
-                showClose_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for showClose_buf_ has to be chosen through deserialisation.")
-            }
-            showClose_buf = (showClose_buf_ as boolean | Resource)
-        }
-        const showClose_result : boolean | Resource | undefined = showClose_buf
-        const preferType_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let preferType_buf : SheetType | undefined
-        if ((preferType_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            preferType_buf = TypeChecker.SheetType_FromNumeric(valueDeserializer.readInt32())
-        }
-        const preferType_result : SheetType | undefined = preferType_buf
-        const title_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let title_buf : SheetTitleOptions | CustomBuilder | undefined
-        if ((title_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const title_buf__selector : int32 = valueDeserializer.readInt8()
-            let title_buf_ : SheetTitleOptions | CustomBuilder | undefined
-            if (title_buf__selector == (0).toChar()) {
-                title_buf_ = SheetTitleOptions_serializer.read(valueDeserializer)
-            }
-            else if (title_buf__selector == (1).toChar()) {
-                const title_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
-                const title_buf__u_call : KPointer = valueDeserializer.readPointer()
-                const title_buf__u_callSync : KPointer = valueDeserializer.readPointer()
-                title_buf_ = ():void => { 
-    const title_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
-    title_buf__u_argsSerializer.writeInt32(title_buf__u_resource.resourceId);
-    title_buf__u_argsSerializer.writePointer(title_buf__u_call);
-    title_buf__u_argsSerializer.writePointer(title_buf__u_callSync);
-    InteropNativeModule._CallCallback(737226752, title_buf__u_argsSerializer.asBuffer(), title_buf__u_argsSerializer.length());
-    title_buf__u_argsSerializer.release();
-    return; }
-            }
-            else {
-                throw new Error("One of the branches for title_buf_ has to be chosen through deserialisation.")
-            }
-            title_buf = (title_buf_ as SheetTitleOptions | CustomBuilder)
-        }
-        const title_result : SheetTitleOptions | CustomBuilder | undefined = title_buf
-        const shouldDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let shouldDismiss_buf : ((sheetDismiss: SheetDismiss) => void) | undefined
-        if ((shouldDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const shouldDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const shouldDismiss_buf__call : KPointer = valueDeserializer.readPointer()
-            const shouldDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
-            shouldDismiss_buf = (sheetDismiss: SheetDismiss):void => { 
-    const shouldDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    shouldDismiss_buf__argsSerializer.writeInt32(shouldDismiss_buf__resource.resourceId);
-    shouldDismiss_buf__argsSerializer.writePointer(shouldDismiss_buf__call);
-    shouldDismiss_buf__argsSerializer.writePointer(shouldDismiss_buf__callSync);
-    SheetDismiss_serializer.write(shouldDismiss_buf__argsSerializer, sheetDismiss);
-    InteropNativeModule._CallCallback(22609082, shouldDismiss_buf__argsSerializer.asBuffer(), shouldDismiss_buf__argsSerializer.length());
-    shouldDismiss_buf__argsSerializer.release();
-    return; }
-        }
-        const shouldDismiss_result : ((sheetDismiss: SheetDismiss) => void) | undefined = shouldDismiss_buf
-        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillDismiss_buf : ((value0: DismissSheetAction) => void) | undefined
-        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onWillDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillDismiss_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillDismiss_buf = (value0: DismissSheetAction):void => { 
-    const onWillDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillDismiss_buf__argsSerializer.writeInt32(onWillDismiss_buf__resource.resourceId);
-    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__call);
-    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__callSync);
-    DismissSheetAction_serializer.write(onWillDismiss_buf__argsSerializer, value0);
-    InteropNativeModule._CallCallback(889549796, onWillDismiss_buf__argsSerializer.asBuffer(), onWillDismiss_buf__argsSerializer.length());
-    onWillDismiss_buf__argsSerializer.release();
-    return; }
-        }
-        const onWillDismiss_result : ((value0: DismissSheetAction) => void) | undefined = onWillDismiss_buf
-        const onWillSpringBackWhenDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillSpringBackWhenDismiss_buf : ((value0: SpringBackAction) => void) | undefined
-        if ((onWillSpringBackWhenDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onWillSpringBackWhenDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillSpringBackWhenDismiss_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillSpringBackWhenDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillSpringBackWhenDismiss_buf = (value0: SpringBackAction):void => { 
-    const onWillSpringBackWhenDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillSpringBackWhenDismiss_buf__argsSerializer.writeInt32(onWillSpringBackWhenDismiss_buf__resource.resourceId);
-    onWillSpringBackWhenDismiss_buf__argsSerializer.writePointer(onWillSpringBackWhenDismiss_buf__call);
-    onWillSpringBackWhenDismiss_buf__argsSerializer.writePointer(onWillSpringBackWhenDismiss_buf__callSync);
-    SpringBackAction_serializer.write(onWillSpringBackWhenDismiss_buf__argsSerializer, value0);
-    InteropNativeModule._CallCallback(1536231691, onWillSpringBackWhenDismiss_buf__argsSerializer.asBuffer(), onWillSpringBackWhenDismiss_buf__argsSerializer.length());
-    onWillSpringBackWhenDismiss_buf__argsSerializer.release();
-    return; }
-        }
-        const onWillSpringBackWhenDismiss_result : ((value0: SpringBackAction) => void) | undefined = onWillSpringBackWhenDismiss_buf
-        const enableOutsideInteractive_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableOutsideInteractive_buf : boolean | undefined
-        if ((enableOutsideInteractive_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            enableOutsideInteractive_buf = valueDeserializer.readBoolean()
+            offset_buf = Position_serializer.read(valueDeserializer)
         }
-        const enableOutsideInteractive_result : boolean | undefined = enableOutsideInteractive_buf
+        const offset_result : Position | undefined = offset_buf
         const width_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let width_buf : Dimension | undefined
         if ((width_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -20897,97 +20918,76 @@ export class SheetOptions_serializer {
             width_buf = (width_buf_ as string | number | Resource)
         }
         const width_result : Dimension | undefined = width_buf
-        const borderWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderWidth_buf : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined
-        if ((borderWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const arrowPointPosition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowPointPosition_buf : ArrowPointPosition | undefined
+        if ((arrowPointPosition_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const borderWidth_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderWidth_buf_ : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined
-            if (borderWidth_buf__selector == (0).toChar()) {
-                const borderWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let borderWidth_buf__u : string | number | Resource | undefined
-                if (borderWidth_buf__u_selector == (0).toChar()) {
-                    borderWidth_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (borderWidth_buf__u_selector == (1).toChar()) {
-                    borderWidth_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (borderWidth_buf__u_selector == (2).toChar()) {
-                    borderWidth_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.")
-                }
-                borderWidth_buf_ = (borderWidth_buf__u as string | number | Resource)
+            arrowPointPosition_buf = TypeChecker.ArrowPointPosition_FromNumeric(valueDeserializer.readInt32())
+        }
+        const arrowPointPosition_result : ArrowPointPosition | undefined = arrowPointPosition_buf
+        const arrowWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowWidth_buf : Dimension | undefined
+        if ((arrowWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const arrowWidth_buf__selector : int32 = valueDeserializer.readInt8()
+            let arrowWidth_buf_ : string | number | Resource | undefined
+            if (arrowWidth_buf__selector == (0).toChar()) {
+                arrowWidth_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (borderWidth_buf__selector == (1).toChar()) {
-                borderWidth_buf_ = EdgeWidths_serializer.read(valueDeserializer)
+            else if (arrowWidth_buf__selector == (1).toChar()) {
+                arrowWidth_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (borderWidth_buf__selector == (2).toChar()) {
-                borderWidth_buf_ = LocalizedEdgeWidths_serializer.read(valueDeserializer)
+            else if (arrowWidth_buf__selector == (2).toChar()) {
+                arrowWidth_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.")
             }
-            borderWidth_buf = (borderWidth_buf_ as Dimension | EdgeWidths | LocalizedEdgeWidths)
+            arrowWidth_buf = (arrowWidth_buf_ as string | number | Resource)
         }
-        const borderWidth_result : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined = borderWidth_buf
-        const borderColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderColor_buf : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined
-        if ((borderColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const arrowWidth_result : Dimension | undefined = arrowWidth_buf
+        const arrowHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowHeight_buf : Dimension | undefined
+        if ((arrowHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const borderColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderColor_buf_ : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined
-            if (borderColor_buf__selector == (0).toChar()) {
-                const borderColor_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let borderColor_buf__u : Color | number | string | Resource | undefined
-                if (borderColor_buf__u_selector == (0).toChar()) {
-                    borderColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-                }
-                else if (borderColor_buf__u_selector == (1).toChar()) {
-                    borderColor_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (borderColor_buf__u_selector == (2).toChar()) {
-                    borderColor_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (borderColor_buf__u_selector == (3).toChar()) {
-                    borderColor_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for borderColor_buf__u has to be chosen through deserialisation.")
-                }
-                borderColor_buf_ = (borderColor_buf__u as Color | number | string | Resource)
+            const arrowHeight_buf__selector : int32 = valueDeserializer.readInt8()
+            let arrowHeight_buf_ : string | number | Resource | undefined
+            if (arrowHeight_buf__selector == (0).toChar()) {
+                arrowHeight_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (borderColor_buf__selector == (1).toChar()) {
-                borderColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
+            else if (arrowHeight_buf__selector == (1).toChar()) {
+                arrowHeight_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (borderColor_buf__selector == (2).toChar()) {
-                borderColor_buf_ = LocalizedEdgeColors_serializer.read(valueDeserializer)
+            else if (arrowHeight_buf__selector == (2).toChar()) {
+                arrowHeight_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for borderColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.")
             }
-            borderColor_buf = (borderColor_buf_ as ResourceColor | EdgeColors | LocalizedEdgeColors)
+            arrowHeight_buf = (arrowHeight_buf_ as string | number | Resource)
         }
-        const borderColor_result : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined = borderColor_buf
-        const borderStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderStyle_buf : BorderStyle | EdgeStyles | undefined
-        if ((borderStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const arrowHeight_result : Dimension | undefined = arrowHeight_buf
+        const radius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let radius_buf : Dimension | undefined
+        if ((radius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const borderStyle_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderStyle_buf_ : BorderStyle | EdgeStyles | undefined
-            if (borderStyle_buf__selector == (0).toChar()) {
-                borderStyle_buf_ = TypeChecker.BorderStyle_FromNumeric(valueDeserializer.readInt32())
+            const radius_buf__selector : int32 = valueDeserializer.readInt8()
+            let radius_buf_ : string | number | Resource | undefined
+            if (radius_buf__selector == (0).toChar()) {
+                radius_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (borderStyle_buf__selector == (1).toChar()) {
-                borderStyle_buf_ = EdgeStyles_serializer.read(valueDeserializer)
+            else if (radius_buf__selector == (1).toChar()) {
+                radius_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (radius_buf__selector == (2).toChar()) {
+                radius_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for radius_buf_ has to be chosen through deserialisation.")
             }
-            borderStyle_buf = (borderStyle_buf_ as BorderStyle | EdgeStyles)
+            radius_buf = (radius_buf_ as string | number | Resource)
         }
-        const borderStyle_result : BorderStyle | EdgeStyles | undefined = borderStyle_buf
+        const radius_result : Dimension | undefined = radius_buf
         const shadow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let shadow_buf : ShadowOptions | ShadowStyle | undefined
         if ((shadow_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -21006,106 +21006,56 @@ export class SheetOptions_serializer {
             shadow_buf = (shadow_buf_ as ShadowOptions | ShadowStyle)
         }
         const shadow_result : ShadowOptions | ShadowStyle | undefined = shadow_buf
-        const onHeightDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onHeightDidChange_buf : ((value0: number) => void) | undefined
-        if ((onHeightDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onHeightDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onHeightDidChange_buf__call : KPointer = valueDeserializer.readPointer()
-            const onHeightDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onHeightDidChange_buf = (value0: number):void => { 
-    const onHeightDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onHeightDidChange_buf__argsSerializer.writeInt32(onHeightDidChange_buf__resource.resourceId);
-    onHeightDidChange_buf__argsSerializer.writePointer(onHeightDidChange_buf__call);
-    onHeightDidChange_buf__argsSerializer.writePointer(onHeightDidChange_buf__callSync);
-    onHeightDidChange_buf__argsSerializer.writeNumber(value0);
-    InteropNativeModule._CallCallback(36519084, onHeightDidChange_buf__argsSerializer.asBuffer(), onHeightDidChange_buf__argsSerializer.length());
-    onHeightDidChange_buf__argsSerializer.release();
-    return; }
-        }
-        const onHeightDidChange_result : ((value0: number) => void) | undefined = onHeightDidChange_buf
-        const mode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let mode_buf : SheetMode | undefined
-        if ((mode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            mode_buf = TypeChecker.SheetMode_FromNumeric(valueDeserializer.readInt32())
-        }
-        const mode_result : SheetMode | undefined = mode_buf
-        const scrollSizeMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let scrollSizeMode_buf : ScrollSizeMode | undefined
-        if ((scrollSizeMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundBlurStyle_buf : BlurStyle | undefined
+        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            scrollSizeMode_buf = TypeChecker.ScrollSizeMode_FromNumeric(valueDeserializer.readInt32())
+            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const scrollSizeMode_result : ScrollSizeMode | undefined = scrollSizeMode_buf
-        const onDetentsDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onDetentsDidChange_buf : ((value0: number) => void) | undefined
-        if ((onDetentsDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
+        const focusable_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let focusable_buf : boolean | undefined
+        if ((focusable_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onDetentsDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onDetentsDidChange_buf__call : KPointer = valueDeserializer.readPointer()
-            const onDetentsDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onDetentsDidChange_buf = (value0: number):void => { 
-    const onDetentsDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onDetentsDidChange_buf__argsSerializer.writeInt32(onDetentsDidChange_buf__resource.resourceId);
-    onDetentsDidChange_buf__argsSerializer.writePointer(onDetentsDidChange_buf__call);
-    onDetentsDidChange_buf__argsSerializer.writePointer(onDetentsDidChange_buf__callSync);
-    onDetentsDidChange_buf__argsSerializer.writeNumber(value0);
-    InteropNativeModule._CallCallback(36519084, onDetentsDidChange_buf__argsSerializer.asBuffer(), onDetentsDidChange_buf__argsSerializer.length());
-    onDetentsDidChange_buf__argsSerializer.release();
-    return; }
+            focusable_buf = valueDeserializer.readBoolean()
         }
-        const onDetentsDidChange_result : ((value0: number) => void) | undefined = onDetentsDidChange_buf
-        const onWidthDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWidthDidChange_buf : ((value0: number) => void) | undefined
-        if ((onWidthDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const focusable_result : boolean | undefined = focusable_buf
+        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let transition_buf : TransitionEffect | undefined
+        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWidthDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWidthDidChange_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWidthDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWidthDidChange_buf = (value0: number):void => { 
-    const onWidthDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWidthDidChange_buf__argsSerializer.writeInt32(onWidthDidChange_buf__resource.resourceId);
-    onWidthDidChange_buf__argsSerializer.writePointer(onWidthDidChange_buf__call);
-    onWidthDidChange_buf__argsSerializer.writePointer(onWidthDidChange_buf__callSync);
-    onWidthDidChange_buf__argsSerializer.writeNumber(value0);
-    InteropNativeModule._CallCallback(36519084, onWidthDidChange_buf__argsSerializer.asBuffer(), onWidthDidChange_buf__argsSerializer.length());
-    onWidthDidChange_buf__argsSerializer.release();
-    return; }
+            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
         }
-        const onWidthDidChange_result : ((value0: number) => void) | undefined = onWidthDidChange_buf
-        const onTypeDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onTypeDidChange_buf : ((value0: SheetType) => void) | undefined
-        if ((onTypeDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const transition_result : TransitionEffect | undefined = transition_buf
+        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillDismiss_buf : boolean | ((value0: DismissPopupAction) => void) | undefined
+        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onTypeDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onTypeDidChange_buf__call : KPointer = valueDeserializer.readPointer()
-            const onTypeDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onTypeDidChange_buf = (value0: SheetType):void => { 
-    const onTypeDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onTypeDidChange_buf__argsSerializer.writeInt32(onTypeDidChange_buf__resource.resourceId);
-    onTypeDidChange_buf__argsSerializer.writePointer(onTypeDidChange_buf__call);
-    onTypeDidChange_buf__argsSerializer.writePointer(onTypeDidChange_buf__callSync);
-    onTypeDidChange_buf__argsSerializer.writeInt32(TypeChecker.SheetType_ToNumeric(value0));
-    InteropNativeModule._CallCallback(-224451112, onTypeDidChange_buf__argsSerializer.asBuffer(), onTypeDidChange_buf__argsSerializer.length());
-    onTypeDidChange_buf__argsSerializer.release();
+            const onWillDismiss_buf__selector : int32 = valueDeserializer.readInt8()
+            let onWillDismiss_buf_ : boolean | ((value0: DismissPopupAction) => void) | undefined
+            if (onWillDismiss_buf__selector == (0).toChar()) {
+                onWillDismiss_buf_ = valueDeserializer.readBoolean()
+            }
+            else if (onWillDismiss_buf__selector == (1).toChar()) {
+                const onWillDismiss_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
+                const onWillDismiss_buf__u_call : KPointer = valueDeserializer.readPointer()
+                const onWillDismiss_buf__u_callSync : KPointer = valueDeserializer.readPointer()
+                onWillDismiss_buf_ = (value0: DismissPopupAction):void => { 
+    const onWillDismiss_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillDismiss_buf__u_argsSerializer.writeInt32(onWillDismiss_buf__u_resource.resourceId);
+    onWillDismiss_buf__u_argsSerializer.writePointer(onWillDismiss_buf__u_call);
+    onWillDismiss_buf__u_argsSerializer.writePointer(onWillDismiss_buf__u_callSync);
+    DismissPopupAction_serializer.write(onWillDismiss_buf__u_argsSerializer, value0);
+    InteropNativeModule._CallCallback(-2004166751, onWillDismiss_buf__u_argsSerializer.asBuffer(), onWillDismiss_buf__u_argsSerializer.length());
+    onWillDismiss_buf__u_argsSerializer.release();
     return; }
+            }
+            else {
+                throw new Error("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.")
+            }
+            onWillDismiss_buf = (onWillDismiss_buf_ as boolean | ((value0: DismissPopupAction) => void))
         }
-        const onTypeDidChange_result : ((value0: SheetType) => void) | undefined = onTypeDidChange_buf
-        const uiContext_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let uiContext_buf : UIContext | undefined
-        if ((uiContext_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            uiContext_buf = (UIContext_serializer.read(valueDeserializer) as UIContext)
-        }
-        const uiContext_result : UIContext | undefined = uiContext_buf
-        const keyboardAvoidMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let keyboardAvoidMode_buf : SheetKeyboardAvoidMode | undefined
-        if ((keyboardAvoidMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            keyboardAvoidMode_buf = TypeChecker.SheetKeyboardAvoidMode_FromNumeric(valueDeserializer.readInt32())
-        }
-        const keyboardAvoidMode_result : SheetKeyboardAvoidMode | undefined = keyboardAvoidMode_buf
+        const onWillDismiss_result : boolean | ((value0: DismissPopupAction) => void) | undefined = onWillDismiss_buf
         const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let enableHoverMode_buf : boolean | undefined
         if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -21113,255 +21063,360 @@ export class SheetOptions_serializer {
             enableHoverMode_buf = valueDeserializer.readBoolean()
         }
         const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
-        const hoverModeArea_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let hoverModeArea_buf : HoverModeAreaType | undefined
-        if ((hoverModeArea_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const followTransformOfTarget_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let followTransformOfTarget_buf : boolean | undefined
+        if ((followTransformOfTarget_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            hoverModeArea_buf = TypeChecker.HoverModeAreaType_FromNumeric(valueDeserializer.readInt32())
+            followTransformOfTarget_buf = valueDeserializer.readBoolean()
         }
-        const hoverModeArea_result : HoverModeAreaType | undefined = hoverModeArea_buf
-        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let offset_buf : Position | undefined
-        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const followTransformOfTarget_result : boolean | undefined = followTransformOfTarget_buf
+        const keyboardAvoidMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let keyboardAvoidMode_buf : KeyboardAvoidMode | undefined
+        if ((keyboardAvoidMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            offset_buf = Position_serializer.read(valueDeserializer)
+            keyboardAvoidMode_buf = TypeChecker.KeyboardAvoidMode_FromNumeric(valueDeserializer.readInt32())
         }
-        const offset_result : Position | undefined = offset_buf
-        const effectEdge_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let effectEdge_buf : number | undefined
-        if ((effectEdge_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            effectEdge_buf = (valueDeserializer.readNumber() as number)
+        const keyboardAvoidMode_result : KeyboardAvoidMode | undefined = keyboardAvoidMode_buf
+        let value : CustomPopupOptions = ({builder: builder_result, placement: placement_result, popupColor: popupColor_result, enableArrow: enableArrow_result, autoCancel: autoCancel_result, onStateChange: onStateChange_result, arrowOffset: arrowOffset_result, showInSubWindow: showInSubWindow_result, mask: mask_result, targetSpace: targetSpace_result, offset: offset_result, width: width_result, arrowPointPosition: arrowPointPosition_result, arrowWidth: arrowWidth_result, arrowHeight: arrowHeight_result, radius: radius_result, shadow: shadow_result, backgroundBlurStyle: backgroundBlurStyle_result, focusable: focusable_result, transition: transition_result, onWillDismiss: onWillDismiss_result, enableHoverMode: enableHoverMode_result, followTransformOfTarget: followTransformOfTarget_result, keyboardAvoidMode: keyboardAvoidMode_result} as CustomPopupOptions)
+        return value
+    }
+}
+export class EventTarget_serializer {
+    public static write(buffer: SerializerBase, value: EventTarget): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_area  = value.area
+        Area_serializer.write(valueSerializer, value_area)
+        const value_id  = value.id
+        let value_id_type : int32 = RuntimeType.UNDEFINED
+        value_id_type = runtimeType(value_id)
+        valueSerializer.writeInt8((value_id_type).toChar())
+        if ((value_id_type) != (RuntimeType.UNDEFINED)) {
+            const value_id_value  = value_id!
+            valueSerializer.writeString(value_id_value)
         }
-        const effectEdge_result : number | undefined = effectEdge_buf
-        const radius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let radius_buf : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined
-        if ((radius_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const radius_buf__selector : int32 = valueDeserializer.readInt8()
-            let radius_buf_ : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined
-            if (radius_buf__selector == (0).toChar()) {
-                radius_buf_ = (LengthMetrics_serializer.read(valueDeserializer) as LengthMetrics)
-            }
-            else if (radius_buf__selector == (1).toChar()) {
-                radius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else if (radius_buf__selector == (2).toChar()) {
-                radius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for radius_buf_ has to be chosen through deserialisation.")
-            }
-            radius_buf = (radius_buf_ as LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses)
-        }
-        const radius_result : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined = radius_buf
-        const detentSelection_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let detentSelection_buf : SheetSize | Length | undefined
-        if ((detentSelection_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const detentSelection_buf__selector : int32 = valueDeserializer.readInt8()
-            let detentSelection_buf_ : SheetSize | Length | undefined
-            if (detentSelection_buf__selector == (0).toChar()) {
-                detentSelection_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (detentSelection_buf__selector == (1).toChar()) {
-                const detentSelection_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let detentSelection_buf__u : string | number | Resource | undefined
-                if (detentSelection_buf__u_selector == (0).toChar()) {
-                    detentSelection_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (detentSelection_buf__u_selector == (1).toChar()) {
-                    detentSelection_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (detentSelection_buf__u_selector == (2).toChar()) {
-                    detentSelection_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for detentSelection_buf__u has to be chosen through deserialisation.")
-                }
-                detentSelection_buf_ = (detentSelection_buf__u as string | number | Resource)
-            }
-            else {
-                throw new Error("One of the branches for detentSelection_buf_ has to be chosen through deserialisation.")
-            }
-            detentSelection_buf = (detentSelection_buf_ as SheetSize | Length)
-        }
-        const detentSelection_result : SheetSize | Length | undefined = detentSelection_buf
-        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let showInSubWindow_buf : boolean | undefined
-        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            showInSubWindow_buf = valueDeserializer.readBoolean()
-        }
-        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
-        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let placement_buf : Placement | undefined
-        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
-        }
-        const placement_result : Placement | undefined = placement_buf
-        const placementOnTarget_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let placementOnTarget_buf : boolean | undefined
-        if ((placementOnTarget_buf_runtimeType) != (RuntimeType.UNDEFINED))
+    }
+    public static read(buffer: DeserializerBase): EventTarget {
+        let valueDeserializer : DeserializerBase = buffer
+        const area_result : Area = Area_serializer.read(valueDeserializer)
+        const id_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let id_buf : string | undefined
+        if ((id_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            placementOnTarget_buf = valueDeserializer.readBoolean()
+            id_buf = (valueDeserializer.readString() as string)
         }
-        const placementOnTarget_result : boolean | undefined = placementOnTarget_buf
-        let value : SheetOptions = ({backgroundColor: backgroundColor_result, onAppear: onAppear_result, onDisappear: onDisappear_result, onWillAppear: onWillAppear_result, onWillDisappear: onWillDisappear_result, height: height_result, dragBar: dragBar_result, maskColor: maskColor_result, detents: detents_result, blurStyle: blurStyle_result, showClose: showClose_result, preferType: preferType_result, title: title_result, shouldDismiss: shouldDismiss_result, onWillDismiss: onWillDismiss_result, onWillSpringBackWhenDismiss: onWillSpringBackWhenDismiss_result, enableOutsideInteractive: enableOutsideInteractive_result, width: width_result, borderWidth: borderWidth_result, borderColor: borderColor_result, borderStyle: borderStyle_result, shadow: shadow_result, onHeightDidChange: onHeightDidChange_result, mode: mode_result, scrollSizeMode: scrollSizeMode_result, onDetentsDidChange: onDetentsDidChange_result, onWidthDidChange: onWidthDidChange_result, onTypeDidChange: onTypeDidChange_result, uiContext: uiContext_result, keyboardAvoidMode: keyboardAvoidMode_result, enableHoverMode: enableHoverMode_result, hoverModeArea: hoverModeArea_result, offset: offset_result, effectEdge: effectEdge_result, radius: radius_result, detentSelection: detentSelection_result, showInSubWindow: showInSubWindow_result, placement: placement_result, placementOnTarget: placementOnTarget_result} as SheetOptions)
+        const id_result : string | undefined = id_buf
+        let value : EventTarget = ({area: area_result, id: id_result} as EventTarget)
         return value
     }
 }
-export class TouchEvent_serializer {
-    public static write(buffer: SerializerBase, value: TouchEvent): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): TouchEvent {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return TouchEventInternal.fromPtr(ptr)
-    }
-}
-export class AccessibilityHoverEvent_serializer {
-    public static write(buffer: SerializerBase, value: AccessibilityHoverEvent): void {
+export class FocusAxisEvent_serializer {
+    public static write(buffer: SerializerBase, value: FocusAxisEvent): void {
         let valueSerializer : SerializerBase = buffer
         valueSerializer.writePointer(toPeerPtr(value))
     }
-    public static read(buffer: DeserializerBase): AccessibilityHoverEvent {
+    public static read(buffer: DeserializerBase): FocusAxisEvent {
         let valueDeserializer : DeserializerBase = buffer
         let ptr : KPointer = valueDeserializer.readPointer()
-        return AccessibilityHoverEventInternal.fromPtr(ptr)
+        return FocusAxisEventInternal.fromPtr(ptr)
     }
 }
-export class AxisEvent_serializer {
-    public static write(buffer: SerializerBase, value: AxisEvent): void {
+export class GeometryInfo_serializer {
+    public static write(buffer: SerializerBase, value: GeometryInfo): void {
         let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
+        const value_width  = value.width
+        valueSerializer.writeNumber(value_width)
+        const value_height  = value.height
+        valueSerializer.writeNumber(value_height)
+        const value_borderWidth  = value.borderWidth
+        EdgeWidths_serializer.write(valueSerializer, value_borderWidth)
+        const value_margin  = value.margin
+        Padding_serializer.write(valueSerializer, value_margin)
+        const value_padding  = value.padding
+        Padding_serializer.write(valueSerializer, value_padding)
     }
-    public static read(buffer: DeserializerBase): AxisEvent {
+    public static read(buffer: DeserializerBase): GeometryInfo {
         let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return AxisEventInternal.fromPtr(ptr)
+        const width_result : number = (valueDeserializer.readNumber() as number)
+        const height_result : number = (valueDeserializer.readNumber() as number)
+        const borderWidth_result : EdgeWidths = EdgeWidths_serializer.read(valueDeserializer)
+        const margin_result : Padding = Padding_serializer.read(valueDeserializer)
+        const padding_result : Padding = Padding_serializer.read(valueDeserializer)
+        let value : GeometryInfo = ({width: width_result, height: height_result, borderWidth: borderWidth_result, margin: margin_result, padding: padding_result} as GeometryInfo)
+        return value
     }
 }
-export class BaseEvent_serializer {
-    public static write(buffer: SerializerBase, value: BaseEvent): void {
+export class HoverEvent_serializer {
+    public static write(buffer: SerializerBase, value: HoverEvent): void {
         let valueSerializer : SerializerBase = buffer
         valueSerializer.writePointer(toPeerPtr(value))
     }
-    public static read(buffer: DeserializerBase): BaseEvent {
+    public static read(buffer: DeserializerBase): HoverEvent {
         let valueDeserializer : DeserializerBase = buffer
         let ptr : KPointer = valueDeserializer.readPointer()
-        return BaseEventInternal.fromPtr(ptr)
+        return HoverEventInternal.fromPtr(ptr)
     }
 }
-export class ClickEvent_serializer {
-    public static write(buffer: SerializerBase, value: ClickEvent): void {
+export class LayoutChild_serializer {
+    public static write(buffer: SerializerBase, value: LayoutChild): void {
         let valueSerializer : SerializerBase = buffer
         valueSerializer.writePointer(toPeerPtr(value))
     }
-    public static read(buffer: DeserializerBase): ClickEvent {
+    public static read(buffer: DeserializerBase): LayoutChild {
         let valueDeserializer : DeserializerBase = buffer
         let ptr : KPointer = valueDeserializer.readPointer()
-        return ClickEventInternal.fromPtr(ptr)
-    }
-}
-export class AsymmetricTransitionOption_serializer {
-    public static write(buffer: SerializerBase, value: AsymmetricTransitionOption): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_appear  = value.appear
-        TransitionEffect_serializer.write(valueSerializer, value_appear)
-        const value_disappear  = value.disappear
-        TransitionEffect_serializer.write(valueSerializer, value_disappear)
-    }
-    public static read(buffer: DeserializerBase): AsymmetricTransitionOption {
-        let valueDeserializer : DeserializerBase = buffer
-        const appear_result : TransitionEffect = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
-        const disappear_result : TransitionEffect = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
-        let value : AsymmetricTransitionOption = ({appear: appear_result, disappear: disappear_result} as AsymmetricTransitionOption)
-        return value
+        return LayoutChildInternal.fromPtr(ptr)
     }
 }
-export class ContentCoverOptions_serializer {
-    public static write(buffer: SerializerBase, value: ContentCoverOptions): void {
+export class MenuOptions_serializer {
+    public static write(buffer: SerializerBase, value: MenuOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_backgroundColor  = value.backgroundColor
-        let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundColor_type = runtimeType(value_backgroundColor)
-        valueSerializer.writeInt8((value_backgroundColor_type).toChar())
-        if ((value_backgroundColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundColor_value  = value_backgroundColor!
-            let value_backgroundColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_backgroundColor_value_type = runtimeType(value_backgroundColor_value)
-            if (TypeChecker.isColor(value_backgroundColor_value)) {
+        const value_offset  = value.offset
+        let value_offset_type : int32 = RuntimeType.UNDEFINED
+        value_offset_type = runtimeType(value_offset)
+        valueSerializer.writeInt8((value_offset_type).toChar())
+        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
+            const value_offset_value  = value_offset!
+            Position_serializer.write(valueSerializer, value_offset_value)
+        }
+        const value_placement  = value.placement
+        let value_placement_type : int32 = RuntimeType.UNDEFINED
+        value_placement_type = runtimeType(value_placement)
+        valueSerializer.writeInt8((value_placement_type).toChar())
+        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
+            const value_placement_value  = (value_placement as Placement)
+            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+        }
+        const value_enableArrow  = value.enableArrow
+        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
+        value_enableArrow_type = runtimeType(value_enableArrow)
+        valueSerializer.writeInt8((value_enableArrow_type).toChar())
+        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableArrow_value  = value_enableArrow!
+            valueSerializer.writeBoolean(value_enableArrow_value)
+        }
+        const value_arrowOffset  = value.arrowOffset
+        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
+        value_arrowOffset_type = runtimeType(value_arrowOffset)
+        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
+        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
+            const value_arrowOffset_value  = value_arrowOffset!
+            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
+            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
+            if (RuntimeType.STRING == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_backgroundColor_value_0  = value_backgroundColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_backgroundColor_value_0))
+                const value_arrowOffset_value_0  = value_arrowOffset_value as string
+                valueSerializer.writeString(value_arrowOffset_value_0)
             }
-            else if (RuntimeType.NUMBER == value_backgroundColor_value_type) {
+            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_backgroundColor_value_1  = value_backgroundColor_value as number
-                valueSerializer.writeNumber(value_backgroundColor_value_1)
+                const value_arrowOffset_value_1  = value_arrowOffset_value as number
+                valueSerializer.writeNumber(value_arrowOffset_value_1)
             }
-            else if (RuntimeType.STRING == value_backgroundColor_value_type) {
+            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_backgroundColor_value_2  = value_backgroundColor_value as string
-                valueSerializer.writeString(value_backgroundColor_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_backgroundColor_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_backgroundColor_value_3  = value_backgroundColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
+                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
+                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
             }
         }
-        const value_onAppear  = value.onAppear
-        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onAppear_type = runtimeType(value_onAppear)
-        valueSerializer.writeInt8((value_onAppear_type).toChar())
-        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onAppear_value  = value_onAppear!
-            valueSerializer.holdAndWriteCallback(value_onAppear_value)
-        }
-        const value_onDisappear  = value.onDisappear
-        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onDisappear_type = runtimeType(value_onDisappear)
-        valueSerializer.writeInt8((value_onDisappear_type).toChar())
-        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onDisappear_value  = value_onDisappear!
-            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
+        const value_preview  = value.preview
+        let value_preview_type : int32 = RuntimeType.UNDEFINED
+        value_preview_type = runtimeType(value_preview)
+        valueSerializer.writeInt8((value_preview_type).toChar())
+        if ((value_preview_type) != (RuntimeType.UNDEFINED)) {
+            const value_preview_value  = value_preview!
+            let value_preview_value_type : int32 = RuntimeType.UNDEFINED
+            value_preview_value_type = runtimeType(value_preview_value)
+            if (TypeChecker.isMenuPreviewMode(value_preview_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_preview_value_0  = value_preview_value as MenuPreviewMode
+                valueSerializer.writeInt32(TypeChecker.MenuPreviewMode_ToNumeric(value_preview_value_0))
+            }
+            else if (RuntimeType.FUNCTION == value_preview_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_preview_value_1  = value_preview_value as CustomBuilder
+                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_preview_value_1))
+            }
         }
-        const value_onWillAppear  = value.onWillAppear
-        let value_onWillAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onWillAppear_type = runtimeType(value_onWillAppear)
-        valueSerializer.writeInt8((value_onWillAppear_type).toChar())
-        if ((value_onWillAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillAppear_value  = value_onWillAppear!
-            valueSerializer.holdAndWriteCallback(value_onWillAppear_value)
+        const value_previewBorderRadius  = value.previewBorderRadius
+        let value_previewBorderRadius_type : int32 = RuntimeType.UNDEFINED
+        value_previewBorderRadius_type = runtimeType(value_previewBorderRadius)
+        valueSerializer.writeInt8((value_previewBorderRadius_type).toChar())
+        if ((value_previewBorderRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_previewBorderRadius_value  = value_previewBorderRadius!
+            let value_previewBorderRadius_value_type : int32 = RuntimeType.UNDEFINED
+            value_previewBorderRadius_value_type = runtimeType(value_previewBorderRadius_value)
+            if ((RuntimeType.STRING == value_previewBorderRadius_value_type) || (RuntimeType.NUMBER == value_previewBorderRadius_value_type) || (RuntimeType.OBJECT == value_previewBorderRadius_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_previewBorderRadius_value_0  = value_previewBorderRadius_value as Length
+                let value_previewBorderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_previewBorderRadius_value_0_type = runtimeType(value_previewBorderRadius_value_0)
+                if (RuntimeType.STRING == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_previewBorderRadius_value_0_0  = value_previewBorderRadius_value_0 as string
+                    valueSerializer.writeString(value_previewBorderRadius_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_previewBorderRadius_value_0_1  = value_previewBorderRadius_value_0 as number
+                    valueSerializer.writeNumber(value_previewBorderRadius_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_previewBorderRadius_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_previewBorderRadius_value_0_2  = value_previewBorderRadius_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_previewBorderRadius_value_0_2)
+                }
+            }
+            else if (TypeChecker.isBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_previewBorderRadius_value_1  = value_previewBorderRadius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_1)
+            }
+            else if (TypeChecker.isLocalizedBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_previewBorderRadius_value_2  = value_previewBorderRadius_value as LocalizedBorderRadiuses
+                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_2)
+            }
         }
-        const value_onWillDisappear  = value.onWillDisappear
-        let value_onWillDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onWillDisappear_type = runtimeType(value_onWillDisappear)
-        valueSerializer.writeInt8((value_onWillDisappear_type).toChar())
-        if ((value_onWillDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillDisappear_value  = value_onWillDisappear!
-            valueSerializer.holdAndWriteCallback(value_onWillDisappear_value)
+        const value_borderRadius  = value.borderRadius
+        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
+        value_borderRadius_type = runtimeType(value_borderRadius)
+        valueSerializer.writeInt8((value_borderRadius_type).toChar())
+        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderRadius_value  = value_borderRadius!
+            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
+            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_borderRadius_value_0  = value_borderRadius_value as Length
+                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
+                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
+                    valueSerializer.writeString(value_borderRadius_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
+                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
+                }
+            }
+            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
+            }
+            else if (TypeChecker.isLocalizedBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_borderRadius_value_2  = value_borderRadius_value as LocalizedBorderRadiuses
+                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_2)
+            }
         }
-        const value_modalTransition  = value.modalTransition
-        let value_modalTransition_type : int32 = RuntimeType.UNDEFINED
-        value_modalTransition_type = runtimeType(value_modalTransition)
-        valueSerializer.writeInt8((value_modalTransition_type).toChar())
-        if ((value_modalTransition_type) != (RuntimeType.UNDEFINED)) {
-            const value_modalTransition_value  = (value_modalTransition as ModalTransition)
-            valueSerializer.writeInt32(TypeChecker.ModalTransition_ToNumeric(value_modalTransition_value))
+        const value_onAppear  = value.onAppear
+        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onAppear_type = runtimeType(value_onAppear)
+        valueSerializer.writeInt8((value_onAppear_type).toChar())
+        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onAppear_value  = value_onAppear!
+            valueSerializer.holdAndWriteCallback(value_onAppear_value)
         }
-        const value_onWillDismiss  = value.onWillDismiss
-        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
-        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
-        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
-        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillDismiss_value  = value_onWillDismiss!
-            valueSerializer.holdAndWriteCallback(value_onWillDismiss_value)
+        const value_onDisappear  = value.onDisappear
+        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onDisappear_type = runtimeType(value_onDisappear)
+        valueSerializer.writeInt8((value_onDisappear_type).toChar())
+        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onDisappear_value  = value_onDisappear!
+            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
+        }
+        const value_aboutToAppear  = value.aboutToAppear
+        let value_aboutToAppear_type : int32 = RuntimeType.UNDEFINED
+        value_aboutToAppear_type = runtimeType(value_aboutToAppear)
+        valueSerializer.writeInt8((value_aboutToAppear_type).toChar())
+        if ((value_aboutToAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_aboutToAppear_value  = value_aboutToAppear!
+            valueSerializer.holdAndWriteCallback(value_aboutToAppear_value)
+        }
+        const value_aboutToDisappear  = value.aboutToDisappear
+        let value_aboutToDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_aboutToDisappear_type = runtimeType(value_aboutToDisappear)
+        valueSerializer.writeInt8((value_aboutToDisappear_type).toChar())
+        if ((value_aboutToDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_aboutToDisappear_value  = value_aboutToDisappear!
+            valueSerializer.holdAndWriteCallback(value_aboutToDisappear_value)
+        }
+        const value_layoutRegionMargin  = value.layoutRegionMargin
+        let value_layoutRegionMargin_type : int32 = RuntimeType.UNDEFINED
+        value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin)
+        valueSerializer.writeInt8((value_layoutRegionMargin_type).toChar())
+        if ((value_layoutRegionMargin_type) != (RuntimeType.UNDEFINED)) {
+            const value_layoutRegionMargin_value  = value_layoutRegionMargin!
+            Padding_serializer.write(valueSerializer, value_layoutRegionMargin_value)
+        }
+        const value_previewAnimationOptions  = value.previewAnimationOptions
+        let value_previewAnimationOptions_type : int32 = RuntimeType.UNDEFINED
+        value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions)
+        valueSerializer.writeInt8((value_previewAnimationOptions_type).toChar())
+        if ((value_previewAnimationOptions_type) != (RuntimeType.UNDEFINED)) {
+            const value_previewAnimationOptions_value  = value_previewAnimationOptions!
+            ContextMenuAnimationOptions_serializer.write(valueSerializer, value_previewAnimationOptions_value)
+        }
+        const value_backgroundColor  = value.backgroundColor
+        let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundColor_type = runtimeType(value_backgroundColor)
+        valueSerializer.writeInt8((value_backgroundColor_type).toChar())
+        if ((value_backgroundColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundColor_value  = value_backgroundColor!
+            let value_backgroundColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_backgroundColor_value_type = runtimeType(value_backgroundColor_value)
+            if (TypeChecker.isColor(value_backgroundColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_backgroundColor_value_0  = value_backgroundColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_backgroundColor_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_backgroundColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_backgroundColor_value_1  = value_backgroundColor_value as number
+                valueSerializer.writeNumber(value_backgroundColor_value_1)
+            }
+            else if (RuntimeType.STRING == value_backgroundColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_backgroundColor_value_2  = value_backgroundColor_value as string
+                valueSerializer.writeString(value_backgroundColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_backgroundColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_backgroundColor_value_3  = value_backgroundColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
+            }
+        }
+        const value_backgroundBlurStyle  = value.backgroundBlurStyle
+        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
+        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
+        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
+            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
+        }
+        const value_backgroundBlurStyleOptions  = value.backgroundBlurStyleOptions
+        let value_backgroundBlurStyleOptions_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions)
+        valueSerializer.writeInt8((value_backgroundBlurStyleOptions_type).toChar())
+        if ((value_backgroundBlurStyleOptions_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundBlurStyleOptions_value  = value_backgroundBlurStyleOptions!
+            BackgroundBlurStyleOptions_serializer.write(valueSerializer, value_backgroundBlurStyleOptions_value)
+        }
+        const value_backgroundEffect  = value.backgroundEffect
+        let value_backgroundEffect_type : int32 = RuntimeType.UNDEFINED
+        value_backgroundEffect_type = runtimeType(value_backgroundEffect)
+        valueSerializer.writeInt8((value_backgroundEffect_type).toChar())
+        if ((value_backgroundEffect_type) != (RuntimeType.UNDEFINED)) {
+            const value_backgroundEffect_value  = value_backgroundEffect!
+            BackgroundEffectOptions_serializer.write(valueSerializer, value_backgroundEffect_value)
         }
         const value_transition  = value.transition
         let value_transition_type : int32 = RuntimeType.UNDEFINED
@@ -21371,33 +21426,267 @@ export class ContentCoverOptions_serializer {
             const value_transition_value  = value_transition!
             TransitionEffect_serializer.write(valueSerializer, value_transition_value)
         }
-    }
-    public static read(buffer: DeserializerBase): ContentCoverOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundColor_buf : ResourceColor | undefined
-        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const value_enableHoverMode  = value.enableHoverMode
+        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
+        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
+        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
+        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableHoverMode_value  = value_enableHoverMode!
+            valueSerializer.writeBoolean(value_enableHoverMode_value)
+        }
+        const value_outlineColor  = value.outlineColor
+        let value_outlineColor_type : int32 = RuntimeType.UNDEFINED
+        value_outlineColor_type = runtimeType(value_outlineColor)
+        valueSerializer.writeInt8((value_outlineColor_type).toChar())
+        if ((value_outlineColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_outlineColor_value  = value_outlineColor!
+            let value_outlineColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_outlineColor_value_type = runtimeType(value_outlineColor_value)
+            if ((TypeChecker.isColor(value_outlineColor_value)) || (RuntimeType.NUMBER == value_outlineColor_value_type) || (RuntimeType.STRING == value_outlineColor_value_type) || (RuntimeType.OBJECT == value_outlineColor_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_outlineColor_value_0  = value_outlineColor_value as ResourceColor
+                let value_outlineColor_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_outlineColor_value_0_type = runtimeType(value_outlineColor_value_0)
+                if (TypeChecker.isColor(value_outlineColor_value_0)) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_outlineColor_value_0_0  = value_outlineColor_value_0 as Color
+                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_outlineColor_value_0_0))
+                }
+                else if (RuntimeType.NUMBER == value_outlineColor_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_outlineColor_value_0_1  = value_outlineColor_value_0 as number
+                    valueSerializer.writeNumber(value_outlineColor_value_0_1)
+                }
+                else if (RuntimeType.STRING == value_outlineColor_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_outlineColor_value_0_2  = value_outlineColor_value_0 as string
+                    valueSerializer.writeString(value_outlineColor_value_0_2)
+                }
+                else if (RuntimeType.OBJECT == value_outlineColor_value_0_type) {
+                    valueSerializer.writeInt8((3).toChar())
+                    const value_outlineColor_value_0_3  = value_outlineColor_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_outlineColor_value_0_3)
+                }
+            }
+            else if (TypeChecker.isEdgeColors(value_outlineColor_value, false, false, false, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_outlineColor_value_1  = value_outlineColor_value as EdgeColors
+                EdgeColors_serializer.write(valueSerializer, value_outlineColor_value_1)
+            }
+        }
+        const value_outlineWidth  = value.outlineWidth
+        let value_outlineWidth_type : int32 = RuntimeType.UNDEFINED
+        value_outlineWidth_type = runtimeType(value_outlineWidth)
+        valueSerializer.writeInt8((value_outlineWidth_type).toChar())
+        if ((value_outlineWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_outlineWidth_value  = value_outlineWidth!
+            let value_outlineWidth_value_type : int32 = RuntimeType.UNDEFINED
+            value_outlineWidth_value_type = runtimeType(value_outlineWidth_value)
+            if ((RuntimeType.STRING == value_outlineWidth_value_type) || (RuntimeType.NUMBER == value_outlineWidth_value_type) || (RuntimeType.OBJECT == value_outlineWidth_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_outlineWidth_value_0  = value_outlineWidth_value as Dimension
+                let value_outlineWidth_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_outlineWidth_value_0_type = runtimeType(value_outlineWidth_value_0)
+                if (RuntimeType.STRING == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_outlineWidth_value_0_0  = value_outlineWidth_value_0 as string
+                    valueSerializer.writeString(value_outlineWidth_value_0_0)
+                }
+                else if (RuntimeType.NUMBER == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_outlineWidth_value_0_1  = value_outlineWidth_value_0 as number
+                    valueSerializer.writeNumber(value_outlineWidth_value_0_1)
+                }
+                else if (RuntimeType.OBJECT == value_outlineWidth_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_outlineWidth_value_0_2  = value_outlineWidth_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_outlineWidth_value_0_2)
+                }
+            }
+            else if (TypeChecker.isEdgeOutlineWidths(value_outlineWidth_value, false, false, false, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_outlineWidth_value_1  = value_outlineWidth_value as EdgeOutlineWidths
+                EdgeOutlineWidths_serializer.write(valueSerializer, value_outlineWidth_value_1)
+            }
+        }
+        const value_hapticFeedbackMode  = value.hapticFeedbackMode
+        let value_hapticFeedbackMode_type : int32 = RuntimeType.UNDEFINED
+        value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode)
+        valueSerializer.writeInt8((value_hapticFeedbackMode_type).toChar())
+        if ((value_hapticFeedbackMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_hapticFeedbackMode_value  = (value_hapticFeedbackMode as HapticFeedbackMode)
+            valueSerializer.writeInt32(TypeChecker.HapticFeedbackMode_ToNumeric(value_hapticFeedbackMode_value))
+        }
+        const value_title  = value.title
+        let value_title_type : int32 = RuntimeType.UNDEFINED
+        value_title_type = runtimeType(value_title)
+        valueSerializer.writeInt8((value_title_type).toChar())
+        if ((value_title_type) != (RuntimeType.UNDEFINED)) {
+            const value_title_value  = value_title!
+            let value_title_value_type : int32 = RuntimeType.UNDEFINED
+            value_title_value_type = runtimeType(value_title_value)
+            if (RuntimeType.STRING == value_title_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_title_value_0  = value_title_value as string
+                valueSerializer.writeString(value_title_value_0)
+            }
+            else if (RuntimeType.OBJECT == value_title_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_title_value_1  = value_title_value as Resource
+                Resource_serializer.write(valueSerializer, value_title_value_1)
+            }
+        }
+        const value_showInSubWindow  = value.showInSubWindow
+        let value_showInSubWindow_type : int32 = RuntimeType.UNDEFINED
+        value_showInSubWindow_type = runtimeType(value_showInSubWindow)
+        valueSerializer.writeInt8((value_showInSubWindow_type).toChar())
+        if ((value_showInSubWindow_type) != (RuntimeType.UNDEFINED)) {
+            const value_showInSubWindow_value  = value_showInSubWindow!
+            valueSerializer.writeBoolean(value_showInSubWindow_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): MenuOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offset_buf : Position | undefined
+        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            offset_buf = Position_serializer.read(valueDeserializer)
+        }
+        const offset_result : Position | undefined = offset_buf
+        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let placement_buf : Placement | undefined
+        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
+        }
+        const placement_result : Placement | undefined = placement_buf
+        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableArrow_buf : boolean | undefined
+        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            enableArrow_buf = valueDeserializer.readBoolean()
+        }
+        const enableArrow_result : boolean | undefined = enableArrow_buf
+        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let arrowOffset_buf : Length | undefined
+        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
+            let arrowOffset_buf_ : string | number | Resource | undefined
+            if (arrowOffset_buf__selector == (0).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (arrowOffset_buf__selector == (1).toChar()) {
+                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (arrowOffset_buf__selector == (2).toChar()) {
+                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
+            }
+            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
+        }
+        const arrowOffset_result : Length | undefined = arrowOffset_buf
+        const preview_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let preview_buf : MenuPreviewMode | CustomBuilder | undefined
+        if ((preview_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const preview_buf__selector : int32 = valueDeserializer.readInt8()
+            let preview_buf_ : MenuPreviewMode | CustomBuilder | undefined
+            if (preview_buf__selector == (0).toChar()) {
+                preview_buf_ = TypeChecker.MenuPreviewMode_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (preview_buf__selector == (1).toChar()) {
+                const preview_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
+                const preview_buf__u_call : KPointer = valueDeserializer.readPointer()
+                const preview_buf__u_callSync : KPointer = valueDeserializer.readPointer()
+                preview_buf_ = ():void => { 
+    const preview_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
+    preview_buf__u_argsSerializer.writeInt32(preview_buf__u_resource.resourceId);
+    preview_buf__u_argsSerializer.writePointer(preview_buf__u_call);
+    preview_buf__u_argsSerializer.writePointer(preview_buf__u_callSync);
+    InteropNativeModule._CallCallback(737226752, preview_buf__u_argsSerializer.asBuffer(), preview_buf__u_argsSerializer.length());
+    preview_buf__u_argsSerializer.release();
+    return; }
+            }
+            else {
+                throw new Error("One of the branches for preview_buf_ has to be chosen through deserialisation.")
+            }
+            preview_buf = (preview_buf_ as MenuPreviewMode | CustomBuilder)
+        }
+        const preview_result : MenuPreviewMode | CustomBuilder | undefined = preview_buf
+        const previewBorderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let previewBorderRadius_buf : BorderRadiusType | undefined
+        if ((previewBorderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let backgroundColor_buf_ : Color | number | string | Resource | undefined
-            if (backgroundColor_buf__selector == (0).toChar()) {
-                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            const previewBorderRadius_buf__selector : int32 = valueDeserializer.readInt8()
+            let previewBorderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
+            if (previewBorderRadius_buf__selector == (0).toChar()) {
+                const previewBorderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let previewBorderRadius_buf__u : string | number | Resource | undefined
+                if (previewBorderRadius_buf__u_selector == (0).toChar()) {
+                    previewBorderRadius_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (previewBorderRadius_buf__u_selector == (1).toChar()) {
+                    previewBorderRadius_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (previewBorderRadius_buf__u_selector == (2).toChar()) {
+                    previewBorderRadius_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.")
+                }
+                previewBorderRadius_buf_ = (previewBorderRadius_buf__u as string | number | Resource)
             }
-            else if (backgroundColor_buf__selector == (1).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+            else if (previewBorderRadius_buf__selector == (1).toChar()) {
+                previewBorderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
-            else if (backgroundColor_buf__selector == (2).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readString() as string)
+            else if (previewBorderRadius_buf__selector == (2).toChar()) {
+                previewBorderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
             }
-            else if (backgroundColor_buf__selector == (3).toChar()) {
-                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+            else {
+                throw new Error("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.")
+            }
+            previewBorderRadius_buf = (previewBorderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
+        }
+        const previewBorderRadius_result : BorderRadiusType | undefined = previewBorderRadius_buf
+        const borderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let borderRadius_buf : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
+        if ((borderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const borderRadius_buf__selector : int32 = valueDeserializer.readInt8()
+            let borderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
+            if (borderRadius_buf__selector == (0).toChar()) {
+                const borderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let borderRadius_buf__u : string | number | Resource | undefined
+                if (borderRadius_buf__u_selector == (0).toChar()) {
+                    borderRadius_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (borderRadius_buf__u_selector == (1).toChar()) {
+                    borderRadius_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (borderRadius_buf__u_selector == (2).toChar()) {
+                    borderRadius_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.")
+                }
+                borderRadius_buf_ = (borderRadius_buf__u as string | number | Resource)
+            }
+            else if (borderRadius_buf__selector == (1).toChar()) {
+                borderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
+            }
+            else if (borderRadius_buf__selector == (2).toChar()) {
+                borderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.")
             }
-            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
+            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
         }
-        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const borderRadius_result : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined = borderRadius_buf
         const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let onAppear_buf : (() => void) | undefined
         if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -21432,121 +21721,99 @@ export class ContentCoverOptions_serializer {
     return; }
         }
         const onDisappear_result : (() => void) | undefined = onDisappear_buf
-        const onWillAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillAppear_buf : (() => void) | undefined
-        if ((onWillAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const aboutToAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let aboutToAppear_buf : (() => void) | undefined
+        if ((aboutToAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWillAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillAppear_buf = ():void => { 
-    const onWillAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillAppear_buf__argsSerializer.writeInt32(onWillAppear_buf__resource.resourceId);
-    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__call);
-    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onWillAppear_buf__argsSerializer.asBuffer(), onWillAppear_buf__argsSerializer.length());
-    onWillAppear_buf__argsSerializer.release();
+            const aboutToAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const aboutToAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const aboutToAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            aboutToAppear_buf = ():void => { 
+    const aboutToAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    aboutToAppear_buf__argsSerializer.writeInt32(aboutToAppear_buf__resource.resourceId);
+    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__call);
+    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, aboutToAppear_buf__argsSerializer.asBuffer(), aboutToAppear_buf__argsSerializer.length());
+    aboutToAppear_buf__argsSerializer.release();
     return; }
         }
-        const onWillAppear_result : (() => void) | undefined = onWillAppear_buf
-        const onWillDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillDisappear_buf : (() => void) | undefined
-        if ((onWillDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const aboutToAppear_result : (() => void) | undefined = aboutToAppear_buf
+        const aboutToDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let aboutToDisappear_buf : (() => void) | undefined
+        if ((aboutToDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWillDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillDisappear_buf = ():void => { 
-    const onWillDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillDisappear_buf__argsSerializer.writeInt32(onWillDisappear_buf__resource.resourceId);
-    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__call);
-    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onWillDisappear_buf__argsSerializer.asBuffer(), onWillDisappear_buf__argsSerializer.length());
-    onWillDisappear_buf__argsSerializer.release();
+            const aboutToDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const aboutToDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const aboutToDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            aboutToDisappear_buf = ():void => { 
+    const aboutToDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    aboutToDisappear_buf__argsSerializer.writeInt32(aboutToDisappear_buf__resource.resourceId);
+    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__call);
+    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, aboutToDisappear_buf__argsSerializer.asBuffer(), aboutToDisappear_buf__argsSerializer.length());
+    aboutToDisappear_buf__argsSerializer.release();
     return; }
         }
-        const onWillDisappear_result : (() => void) | undefined = onWillDisappear_buf
-        const modalTransition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let modalTransition_buf : ModalTransition | undefined
-        if ((modalTransition_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const aboutToDisappear_result : (() => void) | undefined = aboutToDisappear_buf
+        const layoutRegionMargin_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let layoutRegionMargin_buf : Padding | undefined
+        if ((layoutRegionMargin_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            modalTransition_buf = TypeChecker.ModalTransition_FromNumeric(valueDeserializer.readInt32())
+            layoutRegionMargin_buf = Padding_serializer.read(valueDeserializer)
         }
-        const modalTransition_result : ModalTransition | undefined = modalTransition_buf
-        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillDismiss_buf : ((value0: DismissContentCoverAction) => void) | undefined
-        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const layoutRegionMargin_result : Padding | undefined = layoutRegionMargin_buf
+        const previewAnimationOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let previewAnimationOptions_buf : ContextMenuAnimationOptions | undefined
+        if ((previewAnimationOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWillDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onWillDismiss_buf__call : KPointer = valueDeserializer.readPointer()
-            const onWillDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onWillDismiss_buf = (value0: DismissContentCoverAction):void => { 
-    const onWillDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillDismiss_buf__argsSerializer.writeInt32(onWillDismiss_buf__resource.resourceId);
-    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__call);
-    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__callSync);
-    DismissContentCoverAction_serializer.write(onWillDismiss_buf__argsSerializer, value0);
-    InteropNativeModule._CallCallback(-1283506641, onWillDismiss_buf__argsSerializer.asBuffer(), onWillDismiss_buf__argsSerializer.length());
-    onWillDismiss_buf__argsSerializer.release();
-    return; }
+            previewAnimationOptions_buf = ContextMenuAnimationOptions_serializer.read(valueDeserializer)
         }
-        const onWillDismiss_result : ((value0: DismissContentCoverAction) => void) | undefined = onWillDismiss_buf
-        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let transition_buf : TransitionEffect | undefined
-        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const previewAnimationOptions_result : ContextMenuAnimationOptions | undefined = previewAnimationOptions_buf
+        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundColor_buf : ResourceColor | undefined
+        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
-        }
-        const transition_result : TransitionEffect | undefined = transition_buf
-        let value : ContentCoverOptions = ({backgroundColor: backgroundColor_result, onAppear: onAppear_result, onDisappear: onDisappear_result, onWillAppear: onWillAppear_result, onWillDisappear: onWillDisappear_result, modalTransition: modalTransition_result, onWillDismiss: onWillDismiss_result, transition: transition_result} as ContentCoverOptions)
-        return value
-    }
-}
-export class ContextMenuAnimationOptions_serializer {
-    public static write(buffer: SerializerBase, value: ContextMenuAnimationOptions): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_scale  = value.scale
-        let value_scale_type : int32 = RuntimeType.UNDEFINED
-        value_scale_type = runtimeType(value_scale)
-        valueSerializer.writeInt8((value_scale_type).toChar())
-        if ((value_scale_type) != (RuntimeType.UNDEFINED)) {
-            const value_scale_value  = value_scale!
-            const value_scale_value_0  = value_scale_value[0]
-            valueSerializer.writeNumber(value_scale_value_0)
-            const value_scale_value_1  = value_scale_value[1]
-            valueSerializer.writeNumber(value_scale_value_1)
+            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let backgroundColor_buf_ : Color | number | string | Resource | undefined
+            if (backgroundColor_buf__selector == (0).toChar()) {
+                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (backgroundColor_buf__selector == (1).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (backgroundColor_buf__selector == (2).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (backgroundColor_buf__selector == (3).toChar()) {
+                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
+            }
+            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
         }
-        const value_transition  = value.transition
-        let value_transition_type : int32 = RuntimeType.UNDEFINED
-        value_transition_type = runtimeType(value_transition)
-        valueSerializer.writeInt8((value_transition_type).toChar())
-        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
-            const value_transition_value  = value_transition!
-            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
+        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundBlurStyle_buf : BlurStyle | undefined
+        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const value_hoverScale  = value.hoverScale
-        let value_hoverScale_type : int32 = RuntimeType.UNDEFINED
-        value_hoverScale_type = runtimeType(value_hoverScale)
-        valueSerializer.writeInt8((value_hoverScale_type).toChar())
-        if ((value_hoverScale_type) != (RuntimeType.UNDEFINED)) {
-            const value_hoverScale_value  = value_hoverScale!
-            const value_hoverScale_value_0  = value_hoverScale_value[0]
-            valueSerializer.writeNumber(value_hoverScale_value_0)
-            const value_hoverScale_value_1  = value_hoverScale_value[1]
-            valueSerializer.writeNumber(value_hoverScale_value_1)
+        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
+        const backgroundBlurStyleOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundBlurStyleOptions_buf : BackgroundBlurStyleOptions | undefined
+        if ((backgroundBlurStyleOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            backgroundBlurStyleOptions_buf = BackgroundBlurStyleOptions_serializer.read(valueDeserializer)
         }
-    }
-    public static read(buffer: DeserializerBase): ContextMenuAnimationOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const scale_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let scale_buf : AnimationNumberRange | undefined
-        if ((scale_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const backgroundBlurStyleOptions_result : BackgroundBlurStyleOptions | undefined = backgroundBlurStyleOptions_buf
+        const backgroundEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundEffect_buf : BackgroundEffectOptions | undefined
+        if ((backgroundEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const scale_buf__value0 : number = (valueDeserializer.readNumber() as number)
-            const scale_buf__value1 : number = (valueDeserializer.readNumber() as number)
-            scale_buf = ([scale_buf__value0, scale_buf__value1] as AnimationNumberRange)
+            backgroundEffect_buf = BackgroundEffectOptions_serializer.read(valueDeserializer)
         }
-        const scale_result : AnimationNumberRange | undefined = scale_buf
+        const backgroundEffect_result : BackgroundEffectOptions | undefined = backgroundEffect_buf
         const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let transition_buf : TransitionEffect | undefined
         if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -21554,216 +21821,257 @@ export class ContextMenuAnimationOptions_serializer {
             transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
         }
         const transition_result : TransitionEffect | undefined = transition_buf
-        const hoverScale_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let hoverScale_buf : AnimationNumberRange | undefined
-        if ((hoverScale_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableHoverMode_buf : boolean | undefined
+        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const hoverScale_buf__value0 : number = (valueDeserializer.readNumber() as number)
-            const hoverScale_buf__value1 : number = (valueDeserializer.readNumber() as number)
-            hoverScale_buf = ([hoverScale_buf__value0, hoverScale_buf__value1] as AnimationNumberRange)
-        }
-        const hoverScale_result : AnimationNumberRange | undefined = hoverScale_buf
-        let value : ContextMenuAnimationOptions = ({scale: scale_result, transition: transition_result, hoverScale: hoverScale_result} as ContextMenuAnimationOptions)
-        return value
-    }
-}
-export class ContextMenuOptions_serializer {
-    public static write(buffer: SerializerBase, value: ContextMenuOptions): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_offset  = value.offset
-        let value_offset_type : int32 = RuntimeType.UNDEFINED
-        value_offset_type = runtimeType(value_offset)
-        valueSerializer.writeInt8((value_offset_type).toChar())
-        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
-            const value_offset_value  = value_offset!
-            Position_serializer.write(valueSerializer, value_offset_value)
-        }
-        const value_placement  = value.placement
-        let value_placement_type : int32 = RuntimeType.UNDEFINED
-        value_placement_type = runtimeType(value_placement)
-        valueSerializer.writeInt8((value_placement_type).toChar())
-        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
-            const value_placement_value  = (value_placement as Placement)
-            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+            enableHoverMode_buf = valueDeserializer.readBoolean()
         }
-        const value_enableArrow  = value.enableArrow
-        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
-        value_enableArrow_type = runtimeType(value_enableArrow)
-        valueSerializer.writeInt8((value_enableArrow_type).toChar())
-        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableArrow_value  = value_enableArrow!
-            valueSerializer.writeBoolean(value_enableArrow_value)
+        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
+        const outlineColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let outlineColor_buf : ResourceColor | EdgeColors | undefined
+        if ((outlineColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const outlineColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let outlineColor_buf_ : ResourceColor | EdgeColors | undefined
+            if (outlineColor_buf__selector == (0).toChar()) {
+                const outlineColor_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let outlineColor_buf__u : Color | number | string | Resource | undefined
+                if (outlineColor_buf__u_selector == (0).toChar()) {
+                    outlineColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+                }
+                else if (outlineColor_buf__u_selector == (1).toChar()) {
+                    outlineColor_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (outlineColor_buf__u_selector == (2).toChar()) {
+                    outlineColor_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (outlineColor_buf__u_selector == (3).toChar()) {
+                    outlineColor_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.")
+                }
+                outlineColor_buf_ = (outlineColor_buf__u as Color | number | string | Resource)
+            }
+            else if (outlineColor_buf__selector == (1).toChar()) {
+                outlineColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.")
+            }
+            outlineColor_buf = (outlineColor_buf_ as ResourceColor | EdgeColors)
         }
-        const value_arrowOffset  = value.arrowOffset
-        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
-        value_arrowOffset_type = runtimeType(value_arrowOffset)
-        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
-        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowOffset_value  = value_arrowOffset!
-            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
-            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
-            if (RuntimeType.STRING == value_arrowOffset_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_arrowOffset_value_0  = value_arrowOffset_value as string
-                valueSerializer.writeString(value_arrowOffset_value_0)
+        const outlineColor_result : ResourceColor | EdgeColors | undefined = outlineColor_buf
+        const outlineWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let outlineWidth_buf : Dimension | EdgeOutlineWidths | undefined
+        if ((outlineWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const outlineWidth_buf__selector : int32 = valueDeserializer.readInt8()
+            let outlineWidth_buf_ : Dimension | EdgeOutlineWidths | undefined
+            if (outlineWidth_buf__selector == (0).toChar()) {
+                const outlineWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let outlineWidth_buf__u : string | number | Resource | undefined
+                if (outlineWidth_buf__u_selector == (0).toChar()) {
+                    outlineWidth_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (outlineWidth_buf__u_selector == (1).toChar()) {
+                    outlineWidth_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (outlineWidth_buf__u_selector == (2).toChar()) {
+                    outlineWidth_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.")
+                }
+                outlineWidth_buf_ = (outlineWidth_buf__u as string | number | Resource)
             }
-            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_arrowOffset_value_1  = value_arrowOffset_value as number
-                valueSerializer.writeNumber(value_arrowOffset_value_1)
+            else if (outlineWidth_buf__selector == (1).toChar()) {
+                outlineWidth_buf_ = EdgeOutlineWidths_serializer.read(valueDeserializer)
             }
-            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
-                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
+            else {
+                throw new Error("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.")
             }
+            outlineWidth_buf = (outlineWidth_buf_ as Dimension | EdgeOutlineWidths)
         }
-        const value_preview  = value.preview
-        let value_preview_type : int32 = RuntimeType.UNDEFINED
-        value_preview_type = runtimeType(value_preview)
-        valueSerializer.writeInt8((value_preview_type).toChar())
-        if ((value_preview_type) != (RuntimeType.UNDEFINED)) {
-            const value_preview_value  = value_preview!
-            let value_preview_value_type : int32 = RuntimeType.UNDEFINED
-            value_preview_value_type = runtimeType(value_preview_value)
-            if (TypeChecker.isMenuPreviewMode(value_preview_value)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_preview_value_0  = value_preview_value as MenuPreviewMode
-                valueSerializer.writeInt32(TypeChecker.MenuPreviewMode_ToNumeric(value_preview_value_0))
+        const outlineWidth_result : Dimension | EdgeOutlineWidths | undefined = outlineWidth_buf
+        const hapticFeedbackMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let hapticFeedbackMode_buf : HapticFeedbackMode | undefined
+        if ((hapticFeedbackMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            hapticFeedbackMode_buf = TypeChecker.HapticFeedbackMode_FromNumeric(valueDeserializer.readInt32())
+        }
+        const hapticFeedbackMode_result : HapticFeedbackMode | undefined = hapticFeedbackMode_buf
+        const title_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let title_buf : ResourceStr | undefined
+        if ((title_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const title_buf__selector : int32 = valueDeserializer.readInt8()
+            let title_buf_ : string | Resource | undefined
+            if (title_buf__selector == (0).toChar()) {
+                title_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (RuntimeType.FUNCTION == value_preview_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_preview_value_1  = value_preview_value as CustomBuilder
-                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_preview_value_1))
+            else if (title_buf__selector == (1).toChar()) {
+                title_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for title_buf_ has to be chosen through deserialisation.")
             }
+            title_buf = (title_buf_ as string | Resource)
         }
-        const value_previewBorderRadius  = value.previewBorderRadius
-        let value_previewBorderRadius_type : int32 = RuntimeType.UNDEFINED
-        value_previewBorderRadius_type = runtimeType(value_previewBorderRadius)
-        valueSerializer.writeInt8((value_previewBorderRadius_type).toChar())
-        if ((value_previewBorderRadius_type) != (RuntimeType.UNDEFINED)) {
-            const value_previewBorderRadius_value  = value_previewBorderRadius!
-            let value_previewBorderRadius_value_type : int32 = RuntimeType.UNDEFINED
-            value_previewBorderRadius_value_type = runtimeType(value_previewBorderRadius_value)
-            if ((RuntimeType.STRING == value_previewBorderRadius_value_type) || (RuntimeType.NUMBER == value_previewBorderRadius_value_type) || (RuntimeType.OBJECT == value_previewBorderRadius_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_previewBorderRadius_value_0  = value_previewBorderRadius_value as Length
-                let value_previewBorderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_previewBorderRadius_value_0_type = runtimeType(value_previewBorderRadius_value_0)
-                if (RuntimeType.STRING == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_previewBorderRadius_value_0_0  = value_previewBorderRadius_value_0 as string
-                    valueSerializer.writeString(value_previewBorderRadius_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_previewBorderRadius_value_0_1  = value_previewBorderRadius_value_0 as number
-                    valueSerializer.writeNumber(value_previewBorderRadius_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_previewBorderRadius_value_0_2  = value_previewBorderRadius_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_previewBorderRadius_value_0_2)
-                }
+        const title_result : ResourceStr | undefined = title_buf
+        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let showInSubWindow_buf : boolean | undefined
+        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            showInSubWindow_buf = valueDeserializer.readBoolean()
+        }
+        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
+        let value : MenuOptions = ({offset: offset_result, placement: placement_result, enableArrow: enableArrow_result, arrowOffset: arrowOffset_result, preview: preview_result, previewBorderRadius: previewBorderRadius_result, borderRadius: borderRadius_result, onAppear: onAppear_result, onDisappear: onDisappear_result, aboutToAppear: aboutToAppear_result, aboutToDisappear: aboutToDisappear_result, layoutRegionMargin: layoutRegionMargin_result, previewAnimationOptions: previewAnimationOptions_result, backgroundColor: backgroundColor_result, backgroundBlurStyle: backgroundBlurStyle_result, backgroundBlurStyleOptions: backgroundBlurStyleOptions_result, backgroundEffect: backgroundEffect_result, transition: transition_result, enableHoverMode: enableHoverMode_result, outlineColor: outlineColor_result, outlineWidth: outlineWidth_result, hapticFeedbackMode: hapticFeedbackMode_result, title: title_result, showInSubWindow: showInSubWindow_result} as MenuOptions)
+        return value
+    }
+}
+export class MouseEvent_serializer {
+    public static write(buffer: SerializerBase, value: MouseEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): MouseEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return MouseEventInternal.fromPtr(ptr)
+    }
+}
+export class PickerDialogButtonStyle_serializer {
+    public static write(buffer: SerializerBase, value: PickerDialogButtonStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_type  = value.type
+        let value_type_type : int32 = RuntimeType.UNDEFINED
+        value_type_type = runtimeType(value_type)
+        valueSerializer.writeInt8((value_type_type).toChar())
+        if ((value_type_type) != (RuntimeType.UNDEFINED)) {
+            const value_type_value  = (value_type as ButtonType)
+            valueSerializer.writeInt32(TypeChecker.ButtonType_ToNumeric(value_type_value))
+        }
+        const value_style  = value.style
+        let value_style_type : int32 = RuntimeType.UNDEFINED
+        value_style_type = runtimeType(value_style)
+        valueSerializer.writeInt8((value_style_type).toChar())
+        if ((value_style_type) != (RuntimeType.UNDEFINED)) {
+            const value_style_value  = (value_style as ButtonStyleMode)
+            valueSerializer.writeInt32(TypeChecker.ButtonStyleMode_ToNumeric(value_style_value))
+        }
+        const value_role  = value.role
+        let value_role_type : int32 = RuntimeType.UNDEFINED
+        value_role_type = runtimeType(value_role)
+        valueSerializer.writeInt8((value_role_type).toChar())
+        if ((value_role_type) != (RuntimeType.UNDEFINED)) {
+            const value_role_value  = (value_role as ButtonRole)
+            valueSerializer.writeInt32(TypeChecker.ButtonRole_ToNumeric(value_role_value))
+        }
+        const value_fontSize  = value.fontSize
+        let value_fontSize_type : int32 = RuntimeType.UNDEFINED
+        value_fontSize_type = runtimeType(value_fontSize)
+        valueSerializer.writeInt8((value_fontSize_type).toChar())
+        if ((value_fontSize_type) != (RuntimeType.UNDEFINED)) {
+            const value_fontSize_value  = value_fontSize!
+            let value_fontSize_value_type : int32 = RuntimeType.UNDEFINED
+            value_fontSize_value_type = runtimeType(value_fontSize_value)
+            if (RuntimeType.STRING == value_fontSize_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_fontSize_value_0  = value_fontSize_value as string
+                valueSerializer.writeString(value_fontSize_value_0)
             }
-            else if (TypeChecker.isBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
+            else if (RuntimeType.NUMBER == value_fontSize_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_previewBorderRadius_value_1  = value_previewBorderRadius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_1)
+                const value_fontSize_value_1  = value_fontSize_value as number
+                valueSerializer.writeNumber(value_fontSize_value_1)
             }
-            else if (TypeChecker.isLocalizedBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
+            else if (RuntimeType.OBJECT == value_fontSize_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_previewBorderRadius_value_2  = value_previewBorderRadius_value as LocalizedBorderRadiuses
-                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_2)
+                const value_fontSize_value_2  = value_fontSize_value as Resource
+                Resource_serializer.write(valueSerializer, value_fontSize_value_2)
             }
         }
-        const value_borderRadius  = value.borderRadius
-        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
-        value_borderRadius_type = runtimeType(value_borderRadius)
-        valueSerializer.writeInt8((value_borderRadius_type).toChar())
-        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderRadius_value  = value_borderRadius!
-            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
-            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
+        const value_fontColor  = value.fontColor
+        let value_fontColor_type : int32 = RuntimeType.UNDEFINED
+        value_fontColor_type = runtimeType(value_fontColor)
+        valueSerializer.writeInt8((value_fontColor_type).toChar())
+        if ((value_fontColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_fontColor_value  = value_fontColor!
+            let value_fontColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_fontColor_value_type = runtimeType(value_fontColor_value)
+            if (TypeChecker.isColor(value_fontColor_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_borderRadius_value_0  = value_borderRadius_value as Length
-                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
-                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
-                    valueSerializer.writeString(value_borderRadius_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
-                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
-                }
+                const value_fontColor_value_0  = value_fontColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_fontColor_value_0))
             }
-            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+            else if (RuntimeType.NUMBER == value_fontColor_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
+                const value_fontColor_value_1  = value_fontColor_value as number
+                valueSerializer.writeNumber(value_fontColor_value_1)
             }
-            else if (TypeChecker.isLocalizedBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
+            else if (RuntimeType.STRING == value_fontColor_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_borderRadius_value_2  = value_borderRadius_value as LocalizedBorderRadiuses
-                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_2)
+                const value_fontColor_value_2  = value_fontColor_value as string
+                valueSerializer.writeString(value_fontColor_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_fontColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_fontColor_value_3  = value_fontColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_fontColor_value_3)
             }
         }
-        const value_onAppear  = value.onAppear
-        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onAppear_type = runtimeType(value_onAppear)
-        valueSerializer.writeInt8((value_onAppear_type).toChar())
-        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onAppear_value  = value_onAppear!
-            valueSerializer.holdAndWriteCallback(value_onAppear_value)
-        }
-        const value_onDisappear  = value.onDisappear
-        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onDisappear_type = runtimeType(value_onDisappear)
-        valueSerializer.writeInt8((value_onDisappear_type).toChar())
-        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onDisappear_value  = value_onDisappear!
-            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
-        }
-        const value_aboutToAppear  = value.aboutToAppear
-        let value_aboutToAppear_type : int32 = RuntimeType.UNDEFINED
-        value_aboutToAppear_type = runtimeType(value_aboutToAppear)
-        valueSerializer.writeInt8((value_aboutToAppear_type).toChar())
-        if ((value_aboutToAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_aboutToAppear_value  = value_aboutToAppear!
-            valueSerializer.holdAndWriteCallback(value_aboutToAppear_value)
-        }
-        const value_aboutToDisappear  = value.aboutToDisappear
-        let value_aboutToDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_aboutToDisappear_type = runtimeType(value_aboutToDisappear)
-        valueSerializer.writeInt8((value_aboutToDisappear_type).toChar())
-        if ((value_aboutToDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_aboutToDisappear_value  = value_aboutToDisappear!
-            valueSerializer.holdAndWriteCallback(value_aboutToDisappear_value)
+        const value_fontWeight  = value.fontWeight
+        let value_fontWeight_type : int32 = RuntimeType.UNDEFINED
+        value_fontWeight_type = runtimeType(value_fontWeight)
+        valueSerializer.writeInt8((value_fontWeight_type).toChar())
+        if ((value_fontWeight_type) != (RuntimeType.UNDEFINED)) {
+            const value_fontWeight_value  = value_fontWeight!
+            let value_fontWeight_value_type : int32 = RuntimeType.UNDEFINED
+            value_fontWeight_value_type = runtimeType(value_fontWeight_value)
+            if (TypeChecker.isFontWeight(value_fontWeight_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_fontWeight_value_0  = value_fontWeight_value as FontWeight
+                valueSerializer.writeInt32(TypeChecker.FontWeight_ToNumeric(value_fontWeight_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_fontWeight_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_fontWeight_value_1  = value_fontWeight_value as number
+                valueSerializer.writeNumber(value_fontWeight_value_1)
+            }
+            else if (RuntimeType.STRING == value_fontWeight_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_fontWeight_value_2  = value_fontWeight_value as string
+                valueSerializer.writeString(value_fontWeight_value_2)
+            }
         }
-        const value_layoutRegionMargin  = value.layoutRegionMargin
-        let value_layoutRegionMargin_type : int32 = RuntimeType.UNDEFINED
-        value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin)
-        valueSerializer.writeInt8((value_layoutRegionMargin_type).toChar())
-        if ((value_layoutRegionMargin_type) != (RuntimeType.UNDEFINED)) {
-            const value_layoutRegionMargin_value  = value_layoutRegionMargin!
-            Padding_serializer.write(valueSerializer, value_layoutRegionMargin_value)
+        const value_fontStyle  = value.fontStyle
+        let value_fontStyle_type : int32 = RuntimeType.UNDEFINED
+        value_fontStyle_type = runtimeType(value_fontStyle)
+        valueSerializer.writeInt8((value_fontStyle_type).toChar())
+        if ((value_fontStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_fontStyle_value  = (value_fontStyle as FontStyle)
+            valueSerializer.writeInt32(TypeChecker.FontStyle_ToNumeric(value_fontStyle_value))
         }
-        const value_previewAnimationOptions  = value.previewAnimationOptions
-        let value_previewAnimationOptions_type : int32 = RuntimeType.UNDEFINED
-        value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions)
-        valueSerializer.writeInt8((value_previewAnimationOptions_type).toChar())
-        if ((value_previewAnimationOptions_type) != (RuntimeType.UNDEFINED)) {
-            const value_previewAnimationOptions_value  = value_previewAnimationOptions!
-            ContextMenuAnimationOptions_serializer.write(valueSerializer, value_previewAnimationOptions_value)
+        const value_fontFamily  = value.fontFamily
+        let value_fontFamily_type : int32 = RuntimeType.UNDEFINED
+        value_fontFamily_type = runtimeType(value_fontFamily)
+        valueSerializer.writeInt8((value_fontFamily_type).toChar())
+        if ((value_fontFamily_type) != (RuntimeType.UNDEFINED)) {
+            const value_fontFamily_value  = value_fontFamily!
+            let value_fontFamily_value_type : int32 = RuntimeType.UNDEFINED
+            value_fontFamily_value_type = runtimeType(value_fontFamily_value)
+            if (RuntimeType.OBJECT == value_fontFamily_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_fontFamily_value_0  = value_fontFamily_value as Resource
+                Resource_serializer.write(valueSerializer, value_fontFamily_value_0)
+            }
+            else if (RuntimeType.STRING == value_fontFamily_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_fontFamily_value_1  = value_fontFamily_value as string
+                valueSerializer.writeString(value_fontFamily_value_1)
+            }
         }
         const value_backgroundColor  = value.backgroundColor
         let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
@@ -21794,354 +22102,164 @@ export class ContextMenuOptions_serializer {
                 Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
             }
         }
-        const value_backgroundBlurStyle  = value.backgroundBlurStyle
-        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
-        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
-        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
-            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
-        }
-        const value_backgroundBlurStyleOptions  = value.backgroundBlurStyleOptions
-        let value_backgroundBlurStyleOptions_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions)
-        valueSerializer.writeInt8((value_backgroundBlurStyleOptions_type).toChar())
-        if ((value_backgroundBlurStyleOptions_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundBlurStyleOptions_value  = value_backgroundBlurStyleOptions!
-            BackgroundBlurStyleOptions_serializer.write(valueSerializer, value_backgroundBlurStyleOptions_value)
-        }
-        const value_backgroundEffect  = value.backgroundEffect
-        let value_backgroundEffect_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundEffect_type = runtimeType(value_backgroundEffect)
-        valueSerializer.writeInt8((value_backgroundEffect_type).toChar())
-        if ((value_backgroundEffect_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundEffect_value  = value_backgroundEffect!
-            BackgroundEffectOptions_serializer.write(valueSerializer, value_backgroundEffect_value)
-        }
-        const value_transition  = value.transition
-        let value_transition_type : int32 = RuntimeType.UNDEFINED
-        value_transition_type = runtimeType(value_transition)
-        valueSerializer.writeInt8((value_transition_type).toChar())
-        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
-            const value_transition_value  = value_transition!
-            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
-        }
-        const value_enableHoverMode  = value.enableHoverMode
-        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
-        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
-        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
-        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableHoverMode_value  = value_enableHoverMode!
-            valueSerializer.writeBoolean(value_enableHoverMode_value)
-        }
-        const value_outlineColor  = value.outlineColor
-        let value_outlineColor_type : int32 = RuntimeType.UNDEFINED
-        value_outlineColor_type = runtimeType(value_outlineColor)
-        valueSerializer.writeInt8((value_outlineColor_type).toChar())
-        if ((value_outlineColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_outlineColor_value  = value_outlineColor!
-            let value_outlineColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_outlineColor_value_type = runtimeType(value_outlineColor_value)
-            if ((TypeChecker.isColor(value_outlineColor_value)) || (RuntimeType.NUMBER == value_outlineColor_value_type) || (RuntimeType.STRING == value_outlineColor_value_type) || (RuntimeType.OBJECT == value_outlineColor_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_outlineColor_value_0  = value_outlineColor_value as ResourceColor
-                let value_outlineColor_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_outlineColor_value_0_type = runtimeType(value_outlineColor_value_0)
-                if (TypeChecker.isColor(value_outlineColor_value_0)) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_outlineColor_value_0_0  = value_outlineColor_value_0 as Color
-                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_outlineColor_value_0_0))
-                }
-                else if (RuntimeType.NUMBER == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_outlineColor_value_0_1  = value_outlineColor_value_0 as number
-                    valueSerializer.writeNumber(value_outlineColor_value_0_1)
-                }
-                else if (RuntimeType.STRING == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_outlineColor_value_0_2  = value_outlineColor_value_0 as string
-                    valueSerializer.writeString(value_outlineColor_value_0_2)
-                }
-                else if (RuntimeType.OBJECT == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((3).toChar())
-                    const value_outlineColor_value_0_3  = value_outlineColor_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_outlineColor_value_0_3)
-                }
-            }
-            else if (TypeChecker.isEdgeColors(value_outlineColor_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_outlineColor_value_1  = value_outlineColor_value as EdgeColors
-                EdgeColors_serializer.write(valueSerializer, value_outlineColor_value_1)
-            }
-        }
-        const value_outlineWidth  = value.outlineWidth
-        let value_outlineWidth_type : int32 = RuntimeType.UNDEFINED
-        value_outlineWidth_type = runtimeType(value_outlineWidth)
-        valueSerializer.writeInt8((value_outlineWidth_type).toChar())
-        if ((value_outlineWidth_type) != (RuntimeType.UNDEFINED)) {
-            const value_outlineWidth_value  = value_outlineWidth!
-            let value_outlineWidth_value_type : int32 = RuntimeType.UNDEFINED
-            value_outlineWidth_value_type = runtimeType(value_outlineWidth_value)
-            if ((RuntimeType.STRING == value_outlineWidth_value_type) || (RuntimeType.NUMBER == value_outlineWidth_value_type) || (RuntimeType.OBJECT == value_outlineWidth_value_type)) {
+        const value_borderRadius  = value.borderRadius
+        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
+        value_borderRadius_type = runtimeType(value_borderRadius)
+        valueSerializer.writeInt8((value_borderRadius_type).toChar())
+        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderRadius_value  = value_borderRadius!
+            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
+            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_outlineWidth_value_0  = value_outlineWidth_value as Dimension
-                let value_outlineWidth_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_outlineWidth_value_0_type = runtimeType(value_outlineWidth_value_0)
-                if (RuntimeType.STRING == value_outlineWidth_value_0_type) {
+                const value_borderRadius_value_0  = value_borderRadius_value as Length
+                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
+                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
                     valueSerializer.writeInt8((0).toChar())
-                    const value_outlineWidth_value_0_0  = value_outlineWidth_value_0 as string
-                    valueSerializer.writeString(value_outlineWidth_value_0_0)
+                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
+                    valueSerializer.writeString(value_borderRadius_value_0_0)
                 }
-                else if (RuntimeType.NUMBER == value_outlineWidth_value_0_type) {
+                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
                     valueSerializer.writeInt8((1).toChar())
-                    const value_outlineWidth_value_0_1  = value_outlineWidth_value_0 as number
-                    valueSerializer.writeNumber(value_outlineWidth_value_0_1)
+                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
+                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
                 }
-                else if (RuntimeType.OBJECT == value_outlineWidth_value_0_type) {
+                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
                     valueSerializer.writeInt8((2).toChar())
-                    const value_outlineWidth_value_0_2  = value_outlineWidth_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_outlineWidth_value_0_2)
+                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
                 }
             }
-            else if (TypeChecker.isEdgeOutlineWidths(value_outlineWidth_value, false, false, false, false)) {
+            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_outlineWidth_value_1  = value_outlineWidth_value as EdgeOutlineWidths
-                EdgeOutlineWidths_serializer.write(valueSerializer, value_outlineWidth_value_1)
+                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
             }
         }
-        const value_hapticFeedbackMode  = value.hapticFeedbackMode
-        let value_hapticFeedbackMode_type : int32 = RuntimeType.UNDEFINED
-        value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode)
-        valueSerializer.writeInt8((value_hapticFeedbackMode_type).toChar())
-        if ((value_hapticFeedbackMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_hapticFeedbackMode_value  = (value_hapticFeedbackMode as HapticFeedbackMode)
-            valueSerializer.writeInt32(TypeChecker.HapticFeedbackMode_ToNumeric(value_hapticFeedbackMode_value))
+        const value_primary  = value.primary
+        let value_primary_type : int32 = RuntimeType.UNDEFINED
+        value_primary_type = runtimeType(value_primary)
+        valueSerializer.writeInt8((value_primary_type).toChar())
+        if ((value_primary_type) != (RuntimeType.UNDEFINED)) {
+            const value_primary_value  = value_primary!
+            valueSerializer.writeBoolean(value_primary_value)
         }
     }
-    public static read(buffer: DeserializerBase): ContextMenuOptions {
+    public static read(buffer: DeserializerBase): PickerDialogButtonStyle {
         let valueDeserializer : DeserializerBase = buffer
-        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let offset_buf : Position | undefined
-        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            offset_buf = Position_serializer.read(valueDeserializer)
-        }
-        const offset_result : Position | undefined = offset_buf
-        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let placement_buf : Placement | undefined
-        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
-        }
-        const placement_result : Placement | undefined = placement_buf
-        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableArrow_buf : boolean | undefined
-        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            enableArrow_buf = valueDeserializer.readBoolean()
-        }
-        const enableArrow_result : boolean | undefined = enableArrow_buf
-        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowOffset_buf : Length | undefined
-        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const type_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let type_buf : ButtonType | undefined
+        if ((type_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
-            let arrowOffset_buf_ : string | number | Resource | undefined
-            if (arrowOffset_buf__selector == (0).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (arrowOffset_buf__selector == (1).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (arrowOffset_buf__selector == (2).toChar()) {
-                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
-            }
-            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
+            type_buf = TypeChecker.ButtonType_FromNumeric(valueDeserializer.readInt32())
         }
-        const arrowOffset_result : Length | undefined = arrowOffset_buf
-        const preview_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let preview_buf : MenuPreviewMode | CustomBuilder | undefined
-        if ((preview_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const type_result : ButtonType | undefined = type_buf
+        const style_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let style_buf : ButtonStyleMode | undefined
+        if ((style_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const preview_buf__selector : int32 = valueDeserializer.readInt8()
-            let preview_buf_ : MenuPreviewMode | CustomBuilder | undefined
-            if (preview_buf__selector == (0).toChar()) {
-                preview_buf_ = TypeChecker.MenuPreviewMode_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (preview_buf__selector == (1).toChar()) {
-                const preview_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
-                const preview_buf__u_call : KPointer = valueDeserializer.readPointer()
-                const preview_buf__u_callSync : KPointer = valueDeserializer.readPointer()
-                preview_buf_ = ():void => { 
-    const preview_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
-    preview_buf__u_argsSerializer.writeInt32(preview_buf__u_resource.resourceId);
-    preview_buf__u_argsSerializer.writePointer(preview_buf__u_call);
-    preview_buf__u_argsSerializer.writePointer(preview_buf__u_callSync);
-    InteropNativeModule._CallCallback(737226752, preview_buf__u_argsSerializer.asBuffer(), preview_buf__u_argsSerializer.length());
-    preview_buf__u_argsSerializer.release();
-    return; }
-            }
-            else {
-                throw new Error("One of the branches for preview_buf_ has to be chosen through deserialisation.")
-            }
-            preview_buf = (preview_buf_ as MenuPreviewMode | CustomBuilder)
+            style_buf = TypeChecker.ButtonStyleMode_FromNumeric(valueDeserializer.readInt32())
         }
-        const preview_result : MenuPreviewMode | CustomBuilder | undefined = preview_buf
-        const previewBorderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let previewBorderRadius_buf : BorderRadiusType | undefined
-        if ((previewBorderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const style_result : ButtonStyleMode | undefined = style_buf
+        const role_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let role_buf : ButtonRole | undefined
+        if ((role_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const previewBorderRadius_buf__selector : int32 = valueDeserializer.readInt8()
-            let previewBorderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-            if (previewBorderRadius_buf__selector == (0).toChar()) {
-                const previewBorderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let previewBorderRadius_buf__u : string | number | Resource | undefined
-                if (previewBorderRadius_buf__u_selector == (0).toChar()) {
-                    previewBorderRadius_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (previewBorderRadius_buf__u_selector == (1).toChar()) {
-                    previewBorderRadius_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (previewBorderRadius_buf__u_selector == (2).toChar()) {
-                    previewBorderRadius_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.")
-                }
-                previewBorderRadius_buf_ = (previewBorderRadius_buf__u as string | number | Resource)
-            }
-            else if (previewBorderRadius_buf__selector == (1).toChar()) {
-                previewBorderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else if (previewBorderRadius_buf__selector == (2).toChar()) {
-                previewBorderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.")
-            }
-            previewBorderRadius_buf = (previewBorderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
+            role_buf = TypeChecker.ButtonRole_FromNumeric(valueDeserializer.readInt32())
         }
-        const previewBorderRadius_result : BorderRadiusType | undefined = previewBorderRadius_buf
-        const borderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderRadius_buf : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-        if ((borderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const role_result : ButtonRole | undefined = role_buf
+        const fontSize_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fontSize_buf : Length | undefined
+        if ((fontSize_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const borderRadius_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-            if (borderRadius_buf__selector == (0).toChar()) {
-                const borderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let borderRadius_buf__u : string | number | Resource | undefined
-                if (borderRadius_buf__u_selector == (0).toChar()) {
-                    borderRadius_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (borderRadius_buf__u_selector == (1).toChar()) {
-                    borderRadius_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (borderRadius_buf__u_selector == (2).toChar()) {
-                    borderRadius_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.")
-                }
-                borderRadius_buf_ = (borderRadius_buf__u as string | number | Resource)
+            const fontSize_buf__selector : int32 = valueDeserializer.readInt8()
+            let fontSize_buf_ : string | number | Resource | undefined
+            if (fontSize_buf__selector == (0).toChar()) {
+                fontSize_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (borderRadius_buf__selector == (1).toChar()) {
-                borderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
+            else if (fontSize_buf__selector == (1).toChar()) {
+                fontSize_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (borderRadius_buf__selector == (2).toChar()) {
-                borderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
+            else if (fontSize_buf__selector == (2).toChar()) {
+                fontSize_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for fontSize_buf_ has to be chosen through deserialisation.")
             }
-            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
-        }
-        const borderRadius_result : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined = borderRadius_buf
-        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onAppear_buf : (() => void) | undefined
-        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onAppear_buf = ():void => { 
-    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
-    onAppear_buf__argsSerializer.release();
-    return; }
-        }
-        const onAppear_result : (() => void) | undefined = onAppear_buf
-        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onDisappear_buf : (() => void) | undefined
-        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onDisappear_buf = ():void => { 
-    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
-    onDisappear_buf__argsSerializer.release();
-    return; }
+            fontSize_buf = (fontSize_buf_ as string | number | Resource)
         }
-        const onDisappear_result : (() => void) | undefined = onDisappear_buf
-        const aboutToAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let aboutToAppear_buf : (() => void) | undefined
-        if ((aboutToAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const aboutToAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const aboutToAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const aboutToAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            aboutToAppear_buf = ():void => { 
-    const aboutToAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    aboutToAppear_buf__argsSerializer.writeInt32(aboutToAppear_buf__resource.resourceId);
-    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__call);
-    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, aboutToAppear_buf__argsSerializer.asBuffer(), aboutToAppear_buf__argsSerializer.length());
-    aboutToAppear_buf__argsSerializer.release();
-    return; }
+        const fontSize_result : Length | undefined = fontSize_buf
+        const fontColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fontColor_buf : ResourceColor | undefined
+        if ((fontColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const fontColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let fontColor_buf_ : Color | number | string | Resource | undefined
+            if (fontColor_buf__selector == (0).toChar()) {
+                fontColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (fontColor_buf__selector == (1).toChar()) {
+                fontColor_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (fontColor_buf__selector == (2).toChar()) {
+                fontColor_buf_ = (valueDeserializer.readString() as string)
+            }
+            else if (fontColor_buf__selector == (3).toChar()) {
+                fontColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for fontColor_buf_ has to be chosen through deserialisation.")
+            }
+            fontColor_buf = (fontColor_buf_ as Color | number | string | Resource)
         }
-        const aboutToAppear_result : (() => void) | undefined = aboutToAppear_buf
-        const aboutToDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let aboutToDisappear_buf : (() => void) | undefined
-        if ((aboutToDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const fontColor_result : ResourceColor | undefined = fontColor_buf
+        const fontWeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fontWeight_buf : FontWeight | number | string | undefined
+        if ((fontWeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const aboutToDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const aboutToDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const aboutToDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            aboutToDisappear_buf = ():void => { 
-    const aboutToDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    aboutToDisappear_buf__argsSerializer.writeInt32(aboutToDisappear_buf__resource.resourceId);
-    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__call);
-    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, aboutToDisappear_buf__argsSerializer.asBuffer(), aboutToDisappear_buf__argsSerializer.length());
-    aboutToDisappear_buf__argsSerializer.release();
-    return; }
+            const fontWeight_buf__selector : int32 = valueDeserializer.readInt8()
+            let fontWeight_buf_ : FontWeight | number | string | undefined
+            if (fontWeight_buf__selector == (0).toChar()) {
+                fontWeight_buf_ = TypeChecker.FontWeight_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (fontWeight_buf__selector == (1).toChar()) {
+                fontWeight_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (fontWeight_buf__selector == (2).toChar()) {
+                fontWeight_buf_ = (valueDeserializer.readString() as string)
+            }
+            else {
+                throw new Error("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.")
+            }
+            fontWeight_buf = (fontWeight_buf_ as FontWeight | number | string)
         }
-        const aboutToDisappear_result : (() => void) | undefined = aboutToDisappear_buf
-        const layoutRegionMargin_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let layoutRegionMargin_buf : Padding | undefined
-        if ((layoutRegionMargin_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const fontWeight_result : FontWeight | number | string | undefined = fontWeight_buf
+        const fontStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fontStyle_buf : FontStyle | undefined
+        if ((fontStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            layoutRegionMargin_buf = Padding_serializer.read(valueDeserializer)
+            fontStyle_buf = TypeChecker.FontStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const layoutRegionMargin_result : Padding | undefined = layoutRegionMargin_buf
-        const previewAnimationOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let previewAnimationOptions_buf : ContextMenuAnimationOptions | undefined
-        if ((previewAnimationOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const fontStyle_result : FontStyle | undefined = fontStyle_buf
+        const fontFamily_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let fontFamily_buf : Resource | string | undefined
+        if ((fontFamily_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            previewAnimationOptions_buf = ContextMenuAnimationOptions_serializer.read(valueDeserializer)
+            const fontFamily_buf__selector : int32 = valueDeserializer.readInt8()
+            let fontFamily_buf_ : Resource | string | undefined
+            if (fontFamily_buf__selector == (0).toChar()) {
+                fontFamily_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else if (fontFamily_buf__selector == (1).toChar()) {
+                fontFamily_buf_ = (valueDeserializer.readString() as string)
+            }
+            else {
+                throw new Error("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.")
+            }
+            fontFamily_buf = (fontFamily_buf_ as Resource | string)
         }
-        const previewAnimationOptions_result : ContextMenuAnimationOptions | undefined = previewAnimationOptions_buf
+        const fontFamily_result : Resource | string | undefined = fontFamily_buf
         const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let backgroundColor_buf : ResourceColor | undefined
         if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -22166,124 +22284,130 @@ export class ContextMenuOptions_serializer {
             backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
         }
         const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
-        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundBlurStyle_buf : BlurStyle | undefined
-        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
-        }
-        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
-        const backgroundBlurStyleOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundBlurStyleOptions_buf : BackgroundBlurStyleOptions | undefined
-        if ((backgroundBlurStyleOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundBlurStyleOptions_buf = BackgroundBlurStyleOptions_serializer.read(valueDeserializer)
-        }
-        const backgroundBlurStyleOptions_result : BackgroundBlurStyleOptions | undefined = backgroundBlurStyleOptions_buf
-        const backgroundEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundEffect_buf : BackgroundEffectOptions | undefined
-        if ((backgroundEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundEffect_buf = BackgroundEffectOptions_serializer.read(valueDeserializer)
-        }
-        const backgroundEffect_result : BackgroundEffectOptions | undefined = backgroundEffect_buf
-        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let transition_buf : TransitionEffect | undefined
-        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
-        }
-        const transition_result : TransitionEffect | undefined = transition_buf
-        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableHoverMode_buf : boolean | undefined
-        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            enableHoverMode_buf = valueDeserializer.readBoolean()
-        }
-        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
-        const outlineColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let outlineColor_buf : ResourceColor | EdgeColors | undefined
-        if ((outlineColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let borderRadius_buf : Length | BorderRadiuses | undefined
+        if ((borderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const outlineColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let outlineColor_buf_ : ResourceColor | EdgeColors | undefined
-            if (outlineColor_buf__selector == (0).toChar()) {
-                const outlineColor_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let outlineColor_buf__u : Color | number | string | Resource | undefined
-                if (outlineColor_buf__u_selector == (0).toChar()) {
-                    outlineColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-                }
-                else if (outlineColor_buf__u_selector == (1).toChar()) {
-                    outlineColor_buf__u = (valueDeserializer.readNumber() as number)
+            const borderRadius_buf__selector : int32 = valueDeserializer.readInt8()
+            let borderRadius_buf_ : Length | BorderRadiuses | undefined
+            if (borderRadius_buf__selector == (0).toChar()) {
+                const borderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let borderRadius_buf__u : string | number | Resource | undefined
+                if (borderRadius_buf__u_selector == (0).toChar()) {
+                    borderRadius_buf__u = (valueDeserializer.readString() as string)
                 }
-                else if (outlineColor_buf__u_selector == (2).toChar()) {
-                    outlineColor_buf__u = (valueDeserializer.readString() as string)
+                else if (borderRadius_buf__u_selector == (1).toChar()) {
+                    borderRadius_buf__u = (valueDeserializer.readNumber() as number)
                 }
-                else if (outlineColor_buf__u_selector == (3).toChar()) {
-                    outlineColor_buf__u = Resource_serializer.read(valueDeserializer)
+                else if (borderRadius_buf__u_selector == (2).toChar()) {
+                    borderRadius_buf__u = Resource_serializer.read(valueDeserializer)
                 }
                 else {
-                    throw new Error("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.")
+                    throw new Error("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.")
                 }
-                outlineColor_buf_ = (outlineColor_buf__u as Color | number | string | Resource)
+                borderRadius_buf_ = (borderRadius_buf__u as string | number | Resource)
             }
-            else if (outlineColor_buf__selector == (1).toChar()) {
-                outlineColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
+            else if (borderRadius_buf__selector == (1).toChar()) {
+                borderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.")
             }
-            outlineColor_buf = (outlineColor_buf_ as ResourceColor | EdgeColors)
+            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses)
         }
-        const outlineColor_result : ResourceColor | EdgeColors | undefined = outlineColor_buf
-        const outlineWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let outlineWidth_buf : Dimension | EdgeOutlineWidths | undefined
-        if ((outlineWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderRadius_result : Length | BorderRadiuses | undefined = borderRadius_buf
+        const primary_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let primary_buf : boolean | undefined
+        if ((primary_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const outlineWidth_buf__selector : int32 = valueDeserializer.readInt8()
-            let outlineWidth_buf_ : Dimension | EdgeOutlineWidths | undefined
-            if (outlineWidth_buf__selector == (0).toChar()) {
-                const outlineWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let outlineWidth_buf__u : string | number | Resource | undefined
-                if (outlineWidth_buf__u_selector == (0).toChar()) {
-                    outlineWidth_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (outlineWidth_buf__u_selector == (1).toChar()) {
-                    outlineWidth_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (outlineWidth_buf__u_selector == (2).toChar()) {
-                    outlineWidth_buf__u = Resource_serializer.read(valueDeserializer)
-                }
-                else {
-                    throw new Error("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.")
-                }
-                outlineWidth_buf_ = (outlineWidth_buf__u as string | number | Resource)
+            primary_buf = valueDeserializer.readBoolean()
+        }
+        const primary_result : boolean | undefined = primary_buf
+        let value : PickerDialogButtonStyle = ({type: type_result, style: style_result, role: role_result, fontSize: fontSize_result, fontColor: fontColor_result, fontWeight: fontWeight_result, fontStyle: fontStyle_result, fontFamily: fontFamily_result, backgroundColor: backgroundColor_result, borderRadius: borderRadius_result, primary: primary_result} as PickerDialogButtonStyle)
+        return value
+    }
+}
+export class PickerTextStyle_serializer {
+    public static write(buffer: SerializerBase, value: PickerTextStyle): void {
+        let valueSerializer : SerializerBase = buffer
+        const value_color  = value.color
+        let value_color_type : int32 = RuntimeType.UNDEFINED
+        value_color_type = runtimeType(value_color)
+        valueSerializer.writeInt8((value_color_type).toChar())
+        if ((value_color_type) != (RuntimeType.UNDEFINED)) {
+            const value_color_value  = value_color!
+            let value_color_value_type : int32 = RuntimeType.UNDEFINED
+            value_color_value_type = runtimeType(value_color_value)
+            if (TypeChecker.isColor(value_color_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_color_value_0  = value_color_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_color_value_0))
+            }
+            else if (RuntimeType.NUMBER == value_color_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_color_value_1  = value_color_value as number
+                valueSerializer.writeNumber(value_color_value_1)
+            }
+            else if (RuntimeType.STRING == value_color_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_color_value_2  = value_color_value as string
+                valueSerializer.writeString(value_color_value_2)
+            }
+            else if (RuntimeType.OBJECT == value_color_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_color_value_3  = value_color_value as Resource
+                Resource_serializer.write(valueSerializer, value_color_value_3)
+            }
+        }
+        const value_font  = value.font
+        let value_font_type : int32 = RuntimeType.UNDEFINED
+        value_font_type = runtimeType(value_font)
+        valueSerializer.writeInt8((value_font_type).toChar())
+        if ((value_font_type) != (RuntimeType.UNDEFINED)) {
+            const value_font_value  = value_font!
+            Font_serializer.write(valueSerializer, value_font_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): PickerTextStyle {
+        let valueDeserializer : DeserializerBase = buffer
+        const color_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let color_buf : ResourceColor | undefined
+        if ((color_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const color_buf__selector : int32 = valueDeserializer.readInt8()
+            let color_buf_ : Color | number | string | Resource | undefined
+            if (color_buf__selector == (0).toChar()) {
+                color_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (color_buf__selector == (1).toChar()) {
+                color_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (color_buf__selector == (2).toChar()) {
+                color_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (outlineWidth_buf__selector == (1).toChar()) {
-                outlineWidth_buf_ = EdgeOutlineWidths_serializer.read(valueDeserializer)
+            else if (color_buf__selector == (3).toChar()) {
+                color_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for color_buf_ has to be chosen through deserialisation.")
             }
-            outlineWidth_buf = (outlineWidth_buf_ as Dimension | EdgeOutlineWidths)
+            color_buf = (color_buf_ as Color | number | string | Resource)
         }
-        const outlineWidth_result : Dimension | EdgeOutlineWidths | undefined = outlineWidth_buf
-        const hapticFeedbackMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let hapticFeedbackMode_buf : HapticFeedbackMode | undefined
-        if ((hapticFeedbackMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const color_result : ResourceColor | undefined = color_buf
+        const font_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let font_buf : Font | undefined
+        if ((font_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            hapticFeedbackMode_buf = TypeChecker.HapticFeedbackMode_FromNumeric(valueDeserializer.readInt32())
+            font_buf = Font_serializer.read(valueDeserializer)
         }
-        const hapticFeedbackMode_result : HapticFeedbackMode | undefined = hapticFeedbackMode_buf
-        let value : ContextMenuOptions = ({offset: offset_result, placement: placement_result, enableArrow: enableArrow_result, arrowOffset: arrowOffset_result, preview: preview_result, previewBorderRadius: previewBorderRadius_result, borderRadius: borderRadius_result, onAppear: onAppear_result, onDisappear: onDisappear_result, aboutToAppear: aboutToAppear_result, aboutToDisappear: aboutToDisappear_result, layoutRegionMargin: layoutRegionMargin_result, previewAnimationOptions: previewAnimationOptions_result, backgroundColor: backgroundColor_result, backgroundBlurStyle: backgroundBlurStyle_result, backgroundBlurStyleOptions: backgroundBlurStyleOptions_result, backgroundEffect: backgroundEffect_result, transition: transition_result, enableHoverMode: enableHoverMode_result, outlineColor: outlineColor_result, outlineWidth: outlineWidth_result, hapticFeedbackMode: hapticFeedbackMode_result} as ContextMenuOptions)
+        const font_result : Font | undefined = font_buf
+        let value : PickerTextStyle = ({color: color_result, font: font_result} as PickerTextStyle)
         return value
     }
 }
-export class CustomPopupOptions_serializer {
-    public static write(buffer: SerializerBase, value: CustomPopupOptions): void {
+export class PopupCommonOptions_serializer {
+    public static write(buffer: SerializerBase, value: PopupCommonOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_builder  = value.builder
-        valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_builder))
         const value_placement  = value.placement
         let value_placement_type : int32 = RuntimeType.UNDEFINED
         value_placement_type = runtimeType(value_placement)
@@ -22305,20 +22429,20 @@ export class CustomPopupOptions_serializer {
                 const value_popupColor_value_0  = value_popupColor_value as Color
                 valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_popupColor_value_0))
             }
-            else if (RuntimeType.STRING == value_popupColor_value_type) {
+            else if (RuntimeType.NUMBER == value_popupColor_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_popupColor_value_1  = value_popupColor_value as string
-                valueSerializer.writeString(value_popupColor_value_1)
+                const value_popupColor_value_1  = value_popupColor_value as number
+                valueSerializer.writeNumber(value_popupColor_value_1)
             }
-            else if (RuntimeType.OBJECT == value_popupColor_value_type) {
+            else if (RuntimeType.STRING == value_popupColor_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_popupColor_value_2  = value_popupColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_popupColor_value_2)
+                const value_popupColor_value_2  = value_popupColor_value as string
+                valueSerializer.writeString(value_popupColor_value_2)
             }
-            else if (RuntimeType.NUMBER == value_popupColor_value_type) {
+            else if (RuntimeType.OBJECT == value_popupColor_value_type) {
                 valueSerializer.writeInt8((3).toChar())
-                const value_popupColor_value_3  = value_popupColor_value as number
-                valueSerializer.writeNumber(value_popupColor_value_3)
+                const value_popupColor_value_3  = value_popupColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_popupColor_value_3)
             }
         }
         const value_enableArrow  = value.enableArrow
@@ -22610,28 +22734,9 @@ export class CustomPopupOptions_serializer {
             const value_followTransformOfTarget_value  = value_followTransformOfTarget!
             valueSerializer.writeBoolean(value_followTransformOfTarget_value)
         }
-        const value_keyboardAvoidMode  = value.keyboardAvoidMode
-        let value_keyboardAvoidMode_type : int32 = RuntimeType.UNDEFINED
-        value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode)
-        valueSerializer.writeInt8((value_keyboardAvoidMode_type).toChar())
-        if ((value_keyboardAvoidMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_keyboardAvoidMode_value  = (value_keyboardAvoidMode as KeyboardAvoidMode)
-            valueSerializer.writeInt32(TypeChecker.KeyboardAvoidMode_ToNumeric(value_keyboardAvoidMode_value))
-        }
     }
-    public static read(buffer: DeserializerBase): CustomPopupOptions {
+    public static read(buffer: DeserializerBase): PopupCommonOptions {
         let valueDeserializer : DeserializerBase = buffer
-        const builder_buf_resource : CallbackResource = valueDeserializer.readCallbackResource()
-        const builder_buf_call : KPointer = valueDeserializer.readPointer()
-        const builder_buf_callSync : KPointer = valueDeserializer.readPointer()
-        const builder_result : CustomBuilder = ():void => { 
-    const builder_buf_argsSerializer : SerializerBase = SerializerBase.hold();
-    builder_buf_argsSerializer.writeInt32(builder_buf_resource.resourceId);
-    builder_buf_argsSerializer.writePointer(builder_buf_call);
-    builder_buf_argsSerializer.writePointer(builder_buf_callSync);
-    InteropNativeModule._CallCallback(737226752, builder_buf_argsSerializer.asBuffer(), builder_buf_argsSerializer.length());
-    builder_buf_argsSerializer.release();
-    return; }
         const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let placement_buf : Placement | undefined
         if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -22640,29 +22745,29 @@ export class CustomPopupOptions_serializer {
         }
         const placement_result : Placement | undefined = placement_buf
         const popupColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let popupColor_buf : Color | string | Resource | number | undefined
+        let popupColor_buf : ResourceColor | undefined
         if ((popupColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
             const popupColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let popupColor_buf_ : Color | string | Resource | number | undefined
+            let popupColor_buf_ : Color | number | string | Resource | undefined
             if (popupColor_buf__selector == (0).toChar()) {
                 popupColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
             else if (popupColor_buf__selector == (1).toChar()) {
-                popupColor_buf_ = (valueDeserializer.readString() as string)
+                popupColor_buf_ = (valueDeserializer.readNumber() as number)
             }
             else if (popupColor_buf__selector == (2).toChar()) {
-                popupColor_buf_ = Resource_serializer.read(valueDeserializer)
+                popupColor_buf_ = (valueDeserializer.readString() as string)
             }
             else if (popupColor_buf__selector == (3).toChar()) {
-                popupColor_buf_ = (valueDeserializer.readNumber() as number)
+                popupColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
                 throw new Error("One of the branches for popupColor_buf_ has to be chosen through deserialisation.")
             }
-            popupColor_buf = (popupColor_buf_ as Color | string | Resource | number)
+            popupColor_buf = (popupColor_buf_ as Color | number | string | Resource)
         }
-        const popupColor_result : Color | string | Resource | number | undefined = popupColor_buf
+        const popupColor_result : ResourceColor | undefined = popupColor_buf
         const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
         let enableArrow_buf : boolean | undefined
         if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
@@ -22942,215 +23047,91 @@ export class CustomPopupOptions_serializer {
             followTransformOfTarget_buf = valueDeserializer.readBoolean()
         }
         const followTransformOfTarget_result : boolean | undefined = followTransformOfTarget_buf
-        const keyboardAvoidMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let keyboardAvoidMode_buf : KeyboardAvoidMode | undefined
-        if ((keyboardAvoidMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            keyboardAvoidMode_buf = TypeChecker.KeyboardAvoidMode_FromNumeric(valueDeserializer.readInt32())
-        }
-        const keyboardAvoidMode_result : KeyboardAvoidMode | undefined = keyboardAvoidMode_buf
-        let value : CustomPopupOptions = ({builder: builder_result, placement: placement_result, popupColor: popupColor_result, enableArrow: enableArrow_result, autoCancel: autoCancel_result, onStateChange: onStateChange_result, arrowOffset: arrowOffset_result, showInSubWindow: showInSubWindow_result, mask: mask_result, targetSpace: targetSpace_result, offset: offset_result, width: width_result, arrowPointPosition: arrowPointPosition_result, arrowWidth: arrowWidth_result, arrowHeight: arrowHeight_result, radius: radius_result, shadow: shadow_result, backgroundBlurStyle: backgroundBlurStyle_result, focusable: focusable_result, transition: transition_result, onWillDismiss: onWillDismiss_result, enableHoverMode: enableHoverMode_result, followTransformOfTarget: followTransformOfTarget_result, keyboardAvoidMode: keyboardAvoidMode_result} as CustomPopupOptions)
+        let value : PopupCommonOptions = ({placement: placement_result, popupColor: popupColor_result, enableArrow: enableArrow_result, autoCancel: autoCancel_result, onStateChange: onStateChange_result, arrowOffset: arrowOffset_result, showInSubWindow: showInSubWindow_result, mask: mask_result, targetSpace: targetSpace_result, offset: offset_result, width: width_result, arrowPointPosition: arrowPointPosition_result, arrowWidth: arrowWidth_result, arrowHeight: arrowHeight_result, radius: radius_result, shadow: shadow_result, backgroundBlurStyle: backgroundBlurStyle_result, focusable: focusable_result, transition: transition_result, onWillDismiss: onWillDismiss_result, enableHoverMode: enableHoverMode_result, followTransformOfTarget: followTransformOfTarget_result} as PopupCommonOptions)
         return value
     }
 }
-export class MenuOptions_serializer {
-    public static write(buffer: SerializerBase, value: MenuOptions): void {
+export class PopupMessageOptions_serializer {
+    public static write(buffer: SerializerBase, value: PopupMessageOptions): void {
         let valueSerializer : SerializerBase = buffer
-        const value_offset  = value.offset
-        let value_offset_type : int32 = RuntimeType.UNDEFINED
-        value_offset_type = runtimeType(value_offset)
-        valueSerializer.writeInt8((value_offset_type).toChar())
-        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
-            const value_offset_value  = value_offset!
-            Position_serializer.write(valueSerializer, value_offset_value)
-        }
-        const value_placement  = value.placement
-        let value_placement_type : int32 = RuntimeType.UNDEFINED
-        value_placement_type = runtimeType(value_placement)
-        valueSerializer.writeInt8((value_placement_type).toChar())
-        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
-            const value_placement_value  = (value_placement as Placement)
-            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
-        }
-        const value_enableArrow  = value.enableArrow
-        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
-        value_enableArrow_type = runtimeType(value_enableArrow)
-        valueSerializer.writeInt8((value_enableArrow_type).toChar())
-        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableArrow_value  = value_enableArrow!
-            valueSerializer.writeBoolean(value_enableArrow_value)
-        }
-        const value_arrowOffset  = value.arrowOffset
-        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
-        value_arrowOffset_type = runtimeType(value_arrowOffset)
-        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
-        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowOffset_value  = value_arrowOffset!
-            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
-            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
-            if (RuntimeType.STRING == value_arrowOffset_value_type) {
+        const value_textColor  = value.textColor
+        let value_textColor_type : int32 = RuntimeType.UNDEFINED
+        value_textColor_type = runtimeType(value_textColor)
+        valueSerializer.writeInt8((value_textColor_type).toChar())
+        if ((value_textColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_textColor_value  = value_textColor!
+            let value_textColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_textColor_value_type = runtimeType(value_textColor_value)
+            if (TypeChecker.isColor(value_textColor_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_arrowOffset_value_0  = value_arrowOffset_value as string
-                valueSerializer.writeString(value_arrowOffset_value_0)
+                const value_textColor_value_0  = value_textColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_textColor_value_0))
             }
-            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
+            else if (RuntimeType.NUMBER == value_textColor_value_type) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_arrowOffset_value_1  = value_arrowOffset_value as number
-                valueSerializer.writeNumber(value_arrowOffset_value_1)
+                const value_textColor_value_1  = value_textColor_value as number
+                valueSerializer.writeNumber(value_textColor_value_1)
             }
-            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
+            else if (RuntimeType.STRING == value_textColor_value_type) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
-                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
-            }
-        }
-        const value_preview  = value.preview
-        let value_preview_type : int32 = RuntimeType.UNDEFINED
-        value_preview_type = runtimeType(value_preview)
-        valueSerializer.writeInt8((value_preview_type).toChar())
-        if ((value_preview_type) != (RuntimeType.UNDEFINED)) {
-            const value_preview_value  = value_preview!
-            let value_preview_value_type : int32 = RuntimeType.UNDEFINED
-            value_preview_value_type = runtimeType(value_preview_value)
-            if (TypeChecker.isMenuPreviewMode(value_preview_value)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_preview_value_0  = value_preview_value as MenuPreviewMode
-                valueSerializer.writeInt32(TypeChecker.MenuPreviewMode_ToNumeric(value_preview_value_0))
+                const value_textColor_value_2  = value_textColor_value as string
+                valueSerializer.writeString(value_textColor_value_2)
             }
-            else if (RuntimeType.FUNCTION == value_preview_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_preview_value_1  = value_preview_value as CustomBuilder
-                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_preview_value_1))
+            else if (RuntimeType.OBJECT == value_textColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_textColor_value_3  = value_textColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_textColor_value_3)
             }
         }
-        const value_previewBorderRadius  = value.previewBorderRadius
-        let value_previewBorderRadius_type : int32 = RuntimeType.UNDEFINED
-        value_previewBorderRadius_type = runtimeType(value_previewBorderRadius)
-        valueSerializer.writeInt8((value_previewBorderRadius_type).toChar())
-        if ((value_previewBorderRadius_type) != (RuntimeType.UNDEFINED)) {
-            const value_previewBorderRadius_value  = value_previewBorderRadius!
-            let value_previewBorderRadius_value_type : int32 = RuntimeType.UNDEFINED
-            value_previewBorderRadius_value_type = runtimeType(value_previewBorderRadius_value)
-            if ((RuntimeType.STRING == value_previewBorderRadius_value_type) || (RuntimeType.NUMBER == value_previewBorderRadius_value_type) || (RuntimeType.OBJECT == value_previewBorderRadius_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_previewBorderRadius_value_0  = value_previewBorderRadius_value as Length
-                let value_previewBorderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_previewBorderRadius_value_0_type = runtimeType(value_previewBorderRadius_value_0)
-                if (RuntimeType.STRING == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_previewBorderRadius_value_0_0  = value_previewBorderRadius_value_0 as string
-                    valueSerializer.writeString(value_previewBorderRadius_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_previewBorderRadius_value_0_1  = value_previewBorderRadius_value_0 as number
-                    valueSerializer.writeNumber(value_previewBorderRadius_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_previewBorderRadius_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_previewBorderRadius_value_0_2  = value_previewBorderRadius_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_previewBorderRadius_value_0_2)
-                }
-            }
-            else if (TypeChecker.isBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_previewBorderRadius_value_1  = value_previewBorderRadius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_1)
-            }
-            else if (TypeChecker.isLocalizedBorderRadiuses(value_previewBorderRadius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_previewBorderRadius_value_2  = value_previewBorderRadius_value as LocalizedBorderRadiuses
-                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_previewBorderRadius_value_2)
-            }
+        const value_font  = value.font
+        let value_font_type : int32 = RuntimeType.UNDEFINED
+        value_font_type = runtimeType(value_font)
+        valueSerializer.writeInt8((value_font_type).toChar())
+        if ((value_font_type) != (RuntimeType.UNDEFINED)) {
+            const value_font_value  = value_font!
+            Font_serializer.write(valueSerializer, value_font_value)
         }
-        const value_borderRadius  = value.borderRadius
-        let value_borderRadius_type : int32 = RuntimeType.UNDEFINED
-        value_borderRadius_type = runtimeType(value_borderRadius)
-        valueSerializer.writeInt8((value_borderRadius_type).toChar())
-        if ((value_borderRadius_type) != (RuntimeType.UNDEFINED)) {
-            const value_borderRadius_value  = value_borderRadius!
-            let value_borderRadius_value_type : int32 = RuntimeType.UNDEFINED
-            value_borderRadius_value_type = runtimeType(value_borderRadius_value)
-            if ((RuntimeType.STRING == value_borderRadius_value_type) || (RuntimeType.NUMBER == value_borderRadius_value_type) || (RuntimeType.OBJECT == value_borderRadius_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_borderRadius_value_0  = value_borderRadius_value as Length
-                let value_borderRadius_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_borderRadius_value_0_type = runtimeType(value_borderRadius_value_0)
-                if (RuntimeType.STRING == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_borderRadius_value_0_0  = value_borderRadius_value_0 as string
-                    valueSerializer.writeString(value_borderRadius_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_borderRadius_value_0_1  = value_borderRadius_value_0 as number
-                    valueSerializer.writeNumber(value_borderRadius_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_borderRadius_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_borderRadius_value_0_2  = value_borderRadius_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_borderRadius_value_0_2)
-                }
+    }
+    public static read(buffer: DeserializerBase): PopupMessageOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const textColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let textColor_buf : ResourceColor | undefined
+        if ((textColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const textColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let textColor_buf_ : Color | number | string | Resource | undefined
+            if (textColor_buf__selector == (0).toChar()) {
+                textColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (TypeChecker.isBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_borderRadius_value_1  = value_borderRadius_value as BorderRadiuses
-                BorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_1)
+            else if (textColor_buf__selector == (1).toChar()) {
+                textColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-            else if (TypeChecker.isLocalizedBorderRadiuses(value_borderRadius_value, false, false, false, false)) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_borderRadius_value_2  = value_borderRadius_value as LocalizedBorderRadiuses
-                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_borderRadius_value_2)
+            else if (textColor_buf__selector == (2).toChar()) {
+                textColor_buf_ = (valueDeserializer.readString() as string)
             }
+            else if (textColor_buf__selector == (3).toChar()) {
+                textColor_buf_ = Resource_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for textColor_buf_ has to be chosen through deserialisation.")
+            }
+            textColor_buf = (textColor_buf_ as Color | number | string | Resource)
         }
-        const value_onAppear  = value.onAppear
-        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
-        value_onAppear_type = runtimeType(value_onAppear)
-        valueSerializer.writeInt8((value_onAppear_type).toChar())
-        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onAppear_value  = value_onAppear!
-            valueSerializer.holdAndWriteCallback(value_onAppear_value)
-        }
-        const value_onDisappear  = value.onDisappear
-        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_onDisappear_type = runtimeType(value_onDisappear)
-        valueSerializer.writeInt8((value_onDisappear_type).toChar())
-        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_onDisappear_value  = value_onDisappear!
-            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
-        }
-        const value_aboutToAppear  = value.aboutToAppear
-        let value_aboutToAppear_type : int32 = RuntimeType.UNDEFINED
-        value_aboutToAppear_type = runtimeType(value_aboutToAppear)
-        valueSerializer.writeInt8((value_aboutToAppear_type).toChar())
-        if ((value_aboutToAppear_type) != (RuntimeType.UNDEFINED)) {
-            const value_aboutToAppear_value  = value_aboutToAppear!
-            valueSerializer.holdAndWriteCallback(value_aboutToAppear_value)
-        }
-        const value_aboutToDisappear  = value.aboutToDisappear
-        let value_aboutToDisappear_type : int32 = RuntimeType.UNDEFINED
-        value_aboutToDisappear_type = runtimeType(value_aboutToDisappear)
-        valueSerializer.writeInt8((value_aboutToDisappear_type).toChar())
-        if ((value_aboutToDisappear_type) != (RuntimeType.UNDEFINED)) {
-            const value_aboutToDisappear_value  = value_aboutToDisappear!
-            valueSerializer.holdAndWriteCallback(value_aboutToDisappear_value)
-        }
-        const value_layoutRegionMargin  = value.layoutRegionMargin
-        let value_layoutRegionMargin_type : int32 = RuntimeType.UNDEFINED
-        value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin)
-        valueSerializer.writeInt8((value_layoutRegionMargin_type).toChar())
-        if ((value_layoutRegionMargin_type) != (RuntimeType.UNDEFINED)) {
-            const value_layoutRegionMargin_value  = value_layoutRegionMargin!
-            Padding_serializer.write(valueSerializer, value_layoutRegionMargin_value)
-        }
-        const value_previewAnimationOptions  = value.previewAnimationOptions
-        let value_previewAnimationOptions_type : int32 = RuntimeType.UNDEFINED
-        value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions)
-        valueSerializer.writeInt8((value_previewAnimationOptions_type).toChar())
-        if ((value_previewAnimationOptions_type) != (RuntimeType.UNDEFINED)) {
-            const value_previewAnimationOptions_value  = value_previewAnimationOptions!
-            ContextMenuAnimationOptions_serializer.write(valueSerializer, value_previewAnimationOptions_value)
+        const textColor_result : ResourceColor | undefined = textColor_buf
+        const font_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let font_buf : Font | undefined
+        if ((font_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            font_buf = Font_serializer.read(valueDeserializer)
         }
+        const font_result : Font | undefined = font_buf
+        let value : PopupMessageOptions = ({textColor: textColor_result, font: font_result} as PopupMessageOptions)
+        return value
+    }
+}
+export class SheetOptions_serializer {
+    public static write(buffer: SerializerBase, value: SheetOptions): void {
+        let valueSerializer : SerializerBase = buffer
         const value_backgroundColor  = value.backgroundColor
         let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED
         value_backgroundColor_type = runtimeType(value_backgroundColor)
@@ -23180,629 +23161,602 @@ export class MenuOptions_serializer {
                 Resource_serializer.write(valueSerializer, value_backgroundColor_value_3)
             }
         }
-        const value_backgroundBlurStyle  = value.backgroundBlurStyle
-        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
-        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
-        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
-            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
-        }
-        const value_backgroundBlurStyleOptions  = value.backgroundBlurStyleOptions
-        let value_backgroundBlurStyleOptions_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions)
-        valueSerializer.writeInt8((value_backgroundBlurStyleOptions_type).toChar())
-        if ((value_backgroundBlurStyleOptions_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundBlurStyleOptions_value  = value_backgroundBlurStyleOptions!
-            BackgroundBlurStyleOptions_serializer.write(valueSerializer, value_backgroundBlurStyleOptions_value)
-        }
-        const value_backgroundEffect  = value.backgroundEffect
-        let value_backgroundEffect_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundEffect_type = runtimeType(value_backgroundEffect)
-        valueSerializer.writeInt8((value_backgroundEffect_type).toChar())
-        if ((value_backgroundEffect_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundEffect_value  = value_backgroundEffect!
-            BackgroundEffectOptions_serializer.write(valueSerializer, value_backgroundEffect_value)
-        }
-        const value_transition  = value.transition
-        let value_transition_type : int32 = RuntimeType.UNDEFINED
-        value_transition_type = runtimeType(value_transition)
-        valueSerializer.writeInt8((value_transition_type).toChar())
-        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
-            const value_transition_value  = value_transition!
-            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
-        }
-        const value_enableHoverMode  = value.enableHoverMode
-        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
-        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
-        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
-        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableHoverMode_value  = value_enableHoverMode!
-            valueSerializer.writeBoolean(value_enableHoverMode_value)
+        const value_onAppear  = value.onAppear
+        let value_onAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onAppear_type = runtimeType(value_onAppear)
+        valueSerializer.writeInt8((value_onAppear_type).toChar())
+        if ((value_onAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onAppear_value  = value_onAppear!
+            valueSerializer.holdAndWriteCallback(value_onAppear_value)
         }
-        const value_outlineColor  = value.outlineColor
-        let value_outlineColor_type : int32 = RuntimeType.UNDEFINED
-        value_outlineColor_type = runtimeType(value_outlineColor)
-        valueSerializer.writeInt8((value_outlineColor_type).toChar())
-        if ((value_outlineColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_outlineColor_value  = value_outlineColor!
-            let value_outlineColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_outlineColor_value_type = runtimeType(value_outlineColor_value)
-            if ((TypeChecker.isColor(value_outlineColor_value)) || (RuntimeType.NUMBER == value_outlineColor_value_type) || (RuntimeType.STRING == value_outlineColor_value_type) || (RuntimeType.OBJECT == value_outlineColor_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_outlineColor_value_0  = value_outlineColor_value as ResourceColor
-                let value_outlineColor_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_outlineColor_value_0_type = runtimeType(value_outlineColor_value_0)
-                if (TypeChecker.isColor(value_outlineColor_value_0)) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_outlineColor_value_0_0  = value_outlineColor_value_0 as Color
-                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_outlineColor_value_0_0))
-                }
-                else if (RuntimeType.NUMBER == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_outlineColor_value_0_1  = value_outlineColor_value_0 as number
-                    valueSerializer.writeNumber(value_outlineColor_value_0_1)
-                }
-                else if (RuntimeType.STRING == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_outlineColor_value_0_2  = value_outlineColor_value_0 as string
-                    valueSerializer.writeString(value_outlineColor_value_0_2)
-                }
-                else if (RuntimeType.OBJECT == value_outlineColor_value_0_type) {
-                    valueSerializer.writeInt8((3).toChar())
-                    const value_outlineColor_value_0_3  = value_outlineColor_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_outlineColor_value_0_3)
-                }
-            }
-            else if (TypeChecker.isEdgeColors(value_outlineColor_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_outlineColor_value_1  = value_outlineColor_value as EdgeColors
-                EdgeColors_serializer.write(valueSerializer, value_outlineColor_value_1)
-            }
+        const value_onDisappear  = value.onDisappear
+        let value_onDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onDisappear_type = runtimeType(value_onDisappear)
+        valueSerializer.writeInt8((value_onDisappear_type).toChar())
+        if ((value_onDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onDisappear_value  = value_onDisappear!
+            valueSerializer.holdAndWriteCallback(value_onDisappear_value)
         }
-        const value_outlineWidth  = value.outlineWidth
-        let value_outlineWidth_type : int32 = RuntimeType.UNDEFINED
-        value_outlineWidth_type = runtimeType(value_outlineWidth)
-        valueSerializer.writeInt8((value_outlineWidth_type).toChar())
-        if ((value_outlineWidth_type) != (RuntimeType.UNDEFINED)) {
-            const value_outlineWidth_value  = value_outlineWidth!
-            let value_outlineWidth_value_type : int32 = RuntimeType.UNDEFINED
-            value_outlineWidth_value_type = runtimeType(value_outlineWidth_value)
-            if ((RuntimeType.STRING == value_outlineWidth_value_type) || (RuntimeType.NUMBER == value_outlineWidth_value_type) || (RuntimeType.OBJECT == value_outlineWidth_value_type)) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_outlineWidth_value_0  = value_outlineWidth_value as Dimension
-                let value_outlineWidth_value_0_type : int32 = RuntimeType.UNDEFINED
-                value_outlineWidth_value_0_type = runtimeType(value_outlineWidth_value_0)
-                if (RuntimeType.STRING == value_outlineWidth_value_0_type) {
-                    valueSerializer.writeInt8((0).toChar())
-                    const value_outlineWidth_value_0_0  = value_outlineWidth_value_0 as string
-                    valueSerializer.writeString(value_outlineWidth_value_0_0)
-                }
-                else if (RuntimeType.NUMBER == value_outlineWidth_value_0_type) {
-                    valueSerializer.writeInt8((1).toChar())
-                    const value_outlineWidth_value_0_1  = value_outlineWidth_value_0 as number
-                    valueSerializer.writeNumber(value_outlineWidth_value_0_1)
-                }
-                else if (RuntimeType.OBJECT == value_outlineWidth_value_0_type) {
-                    valueSerializer.writeInt8((2).toChar())
-                    const value_outlineWidth_value_0_2  = value_outlineWidth_value_0 as Resource
-                    Resource_serializer.write(valueSerializer, value_outlineWidth_value_0_2)
-                }
-            }
-            else if (TypeChecker.isEdgeOutlineWidths(value_outlineWidth_value, false, false, false, false)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_outlineWidth_value_1  = value_outlineWidth_value as EdgeOutlineWidths
-                EdgeOutlineWidths_serializer.write(valueSerializer, value_outlineWidth_value_1)
-            }
+        const value_onWillAppear  = value.onWillAppear
+        let value_onWillAppear_type : int32 = RuntimeType.UNDEFINED
+        value_onWillAppear_type = runtimeType(value_onWillAppear)
+        valueSerializer.writeInt8((value_onWillAppear_type).toChar())
+        if ((value_onWillAppear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillAppear_value  = value_onWillAppear!
+            valueSerializer.holdAndWriteCallback(value_onWillAppear_value)
         }
-        const value_hapticFeedbackMode  = value.hapticFeedbackMode
-        let value_hapticFeedbackMode_type : int32 = RuntimeType.UNDEFINED
-        value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode)
-        valueSerializer.writeInt8((value_hapticFeedbackMode_type).toChar())
-        if ((value_hapticFeedbackMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_hapticFeedbackMode_value  = (value_hapticFeedbackMode as HapticFeedbackMode)
-            valueSerializer.writeInt32(TypeChecker.HapticFeedbackMode_ToNumeric(value_hapticFeedbackMode_value))
+        const value_onWillDisappear  = value.onWillDisappear
+        let value_onWillDisappear_type : int32 = RuntimeType.UNDEFINED
+        value_onWillDisappear_type = runtimeType(value_onWillDisappear)
+        valueSerializer.writeInt8((value_onWillDisappear_type).toChar())
+        if ((value_onWillDisappear_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillDisappear_value  = value_onWillDisappear!
+            valueSerializer.holdAndWriteCallback(value_onWillDisappear_value)
         }
-        const value_title  = value.title
-        let value_title_type : int32 = RuntimeType.UNDEFINED
-        value_title_type = runtimeType(value_title)
-        valueSerializer.writeInt8((value_title_type).toChar())
-        if ((value_title_type) != (RuntimeType.UNDEFINED)) {
-            const value_title_value  = value_title!
-            let value_title_value_type : int32 = RuntimeType.UNDEFINED
-            value_title_value_type = runtimeType(value_title_value)
-            if (RuntimeType.STRING == value_title_value_type) {
+        const value_height  = value.height
+        let value_height_type : int32 = RuntimeType.UNDEFINED
+        value_height_type = runtimeType(value_height)
+        valueSerializer.writeInt8((value_height_type).toChar())
+        if ((value_height_type) != (RuntimeType.UNDEFINED)) {
+            const value_height_value  = value_height!
+            let value_height_value_type : int32 = RuntimeType.UNDEFINED
+            value_height_value_type = runtimeType(value_height_value)
+            if (TypeChecker.isSheetSize(value_height_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_title_value_0  = value_title_value as string
-                valueSerializer.writeString(value_title_value_0)
+                const value_height_value_0  = value_height_value as SheetSize
+                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_height_value_0))
             }
-            else if (RuntimeType.OBJECT == value_title_value_type) {
+            else if ((RuntimeType.STRING == value_height_value_type) || (RuntimeType.NUMBER == value_height_value_type) || (RuntimeType.OBJECT == value_height_value_type)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_title_value_1  = value_title_value as Resource
-                Resource_serializer.write(valueSerializer, value_title_value_1)
+                const value_height_value_1  = value_height_value as Length
+                let value_height_value_1_type : int32 = RuntimeType.UNDEFINED
+                value_height_value_1_type = runtimeType(value_height_value_1)
+                if (RuntimeType.STRING == value_height_value_1_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_height_value_1_0  = value_height_value_1 as string
+                    valueSerializer.writeString(value_height_value_1_0)
+                }
+                else if (RuntimeType.NUMBER == value_height_value_1_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_height_value_1_1  = value_height_value_1 as number
+                    valueSerializer.writeNumber(value_height_value_1_1)
+                }
+                else if (RuntimeType.OBJECT == value_height_value_1_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_height_value_1_2  = value_height_value_1 as Resource
+                    Resource_serializer.write(valueSerializer, value_height_value_1_2)
+                }
             }
         }
-        const value_showInSubWindow  = value.showInSubWindow
-        let value_showInSubWindow_type : int32 = RuntimeType.UNDEFINED
-        value_showInSubWindow_type = runtimeType(value_showInSubWindow)
-        valueSerializer.writeInt8((value_showInSubWindow_type).toChar())
-        if ((value_showInSubWindow_type) != (RuntimeType.UNDEFINED)) {
-            const value_showInSubWindow_value  = value_showInSubWindow!
-            valueSerializer.writeBoolean(value_showInSubWindow_value)
-        }
-    }
-    public static read(buffer: DeserializerBase): MenuOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let offset_buf : Position | undefined
-        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            offset_buf = Position_serializer.read(valueDeserializer)
-        }
-        const offset_result : Position | undefined = offset_buf
-        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let placement_buf : Placement | undefined
-        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
-        }
-        const placement_result : Placement | undefined = placement_buf
-        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableArrow_buf : boolean | undefined
-        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            enableArrow_buf = valueDeserializer.readBoolean()
+        const value_dragBar  = value.dragBar
+        let value_dragBar_type : int32 = RuntimeType.UNDEFINED
+        value_dragBar_type = runtimeType(value_dragBar)
+        valueSerializer.writeInt8((value_dragBar_type).toChar())
+        if ((value_dragBar_type) != (RuntimeType.UNDEFINED)) {
+            const value_dragBar_value  = value_dragBar!
+            valueSerializer.writeBoolean(value_dragBar_value)
         }
-        const enableArrow_result : boolean | undefined = enableArrow_buf
-        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowOffset_buf : Length | undefined
-        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
-            let arrowOffset_buf_ : string | number | Resource | undefined
-            if (arrowOffset_buf__selector == (0).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readString() as string)
+        const value_maskColor  = value.maskColor
+        let value_maskColor_type : int32 = RuntimeType.UNDEFINED
+        value_maskColor_type = runtimeType(value_maskColor)
+        valueSerializer.writeInt8((value_maskColor_type).toChar())
+        if ((value_maskColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_maskColor_value  = value_maskColor!
+            let value_maskColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_maskColor_value_type = runtimeType(value_maskColor_value)
+            if (TypeChecker.isColor(value_maskColor_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_maskColor_value_0  = value_maskColor_value as Color
+                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_maskColor_value_0))
             }
-            else if (arrowOffset_buf__selector == (1).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
+            else if (RuntimeType.NUMBER == value_maskColor_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_maskColor_value_1  = value_maskColor_value as number
+                valueSerializer.writeNumber(value_maskColor_value_1)
             }
-            else if (arrowOffset_buf__selector == (2).toChar()) {
-                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (RuntimeType.STRING == value_maskColor_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_maskColor_value_2  = value_maskColor_value as string
+                valueSerializer.writeString(value_maskColor_value_2)
             }
-            else {
-                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
+            else if (RuntimeType.OBJECT == value_maskColor_value_type) {
+                valueSerializer.writeInt8((3).toChar())
+                const value_maskColor_value_3  = value_maskColor_value as Resource
+                Resource_serializer.write(valueSerializer, value_maskColor_value_3)
             }
-            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
         }
-        const arrowOffset_result : Length | undefined = arrowOffset_buf
-        const preview_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let preview_buf : MenuPreviewMode | CustomBuilder | undefined
-        if ((preview_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const preview_buf__selector : int32 = valueDeserializer.readInt8()
-            let preview_buf_ : MenuPreviewMode | CustomBuilder | undefined
-            if (preview_buf__selector == (0).toChar()) {
-                preview_buf_ = TypeChecker.MenuPreviewMode_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (preview_buf__selector == (1).toChar()) {
-                const preview_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
-                const preview_buf__u_call : KPointer = valueDeserializer.readPointer()
-                const preview_buf__u_callSync : KPointer = valueDeserializer.readPointer()
-                preview_buf_ = ():void => { 
-    const preview_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
-    preview_buf__u_argsSerializer.writeInt32(preview_buf__u_resource.resourceId);
-    preview_buf__u_argsSerializer.writePointer(preview_buf__u_call);
-    preview_buf__u_argsSerializer.writePointer(preview_buf__u_callSync);
-    InteropNativeModule._CallCallback(737226752, preview_buf__u_argsSerializer.asBuffer(), preview_buf__u_argsSerializer.length());
-    preview_buf__u_argsSerializer.release();
-    return; }
-            }
-            else {
-                throw new Error("One of the branches for preview_buf_ has to be chosen through deserialisation.")
+        const value_detents  = value.detents
+        let value_detents_type : int32 = RuntimeType.UNDEFINED
+        value_detents_type = runtimeType(value_detents)
+        valueSerializer.writeInt8((value_detents_type).toChar())
+        if ((value_detents_type) != (RuntimeType.UNDEFINED)) {
+            const value_detents_value  = value_detents!
+            const value_detents_value_0  = value_detents_value[0]
+            let value_detents_value_0_type : int32 = RuntimeType.UNDEFINED
+            value_detents_value_0_type = runtimeType(value_detents_value_0)
+            if (TypeChecker.isSheetSize(value_detents_value_0)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_detents_value_0_0  = value_detents_value_0 as SheetSize
+                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_0_0))
             }
-            preview_buf = (preview_buf_ as MenuPreviewMode | CustomBuilder)
-        }
-        const preview_result : MenuPreviewMode | CustomBuilder | undefined = preview_buf
-        const previewBorderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let previewBorderRadius_buf : BorderRadiusType | undefined
-        if ((previewBorderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const previewBorderRadius_buf__selector : int32 = valueDeserializer.readInt8()
-            let previewBorderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-            if (previewBorderRadius_buf__selector == (0).toChar()) {
-                const previewBorderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let previewBorderRadius_buf__u : string | number | Resource | undefined
-                if (previewBorderRadius_buf__u_selector == (0).toChar()) {
-                    previewBorderRadius_buf__u = (valueDeserializer.readString() as string)
-                }
-                else if (previewBorderRadius_buf__u_selector == (1).toChar()) {
-                    previewBorderRadius_buf__u = (valueDeserializer.readNumber() as number)
+            else if ((RuntimeType.STRING == value_detents_value_0_type) || (RuntimeType.NUMBER == value_detents_value_0_type) || (RuntimeType.OBJECT == value_detents_value_0_type)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_detents_value_0_1  = value_detents_value_0 as Length
+                let value_detents_value_0_1_type : int32 = RuntimeType.UNDEFINED
+                value_detents_value_0_1_type = runtimeType(value_detents_value_0_1)
+                if (RuntimeType.STRING == value_detents_value_0_1_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_detents_value_0_1_0  = value_detents_value_0_1 as string
+                    valueSerializer.writeString(value_detents_value_0_1_0)
                 }
-                else if (previewBorderRadius_buf__u_selector == (2).toChar()) {
-                    previewBorderRadius_buf__u = Resource_serializer.read(valueDeserializer)
+                else if (RuntimeType.NUMBER == value_detents_value_0_1_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_detents_value_0_1_1  = value_detents_value_0_1 as number
+                    valueSerializer.writeNumber(value_detents_value_0_1_1)
                 }
-                else {
-                    throw new Error("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.")
+                else if (RuntimeType.OBJECT == value_detents_value_0_1_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_detents_value_0_1_2  = value_detents_value_0_1 as Resource
+                    Resource_serializer.write(valueSerializer, value_detents_value_0_1_2)
                 }
-                previewBorderRadius_buf_ = (previewBorderRadius_buf__u as string | number | Resource)
-            }
-            else if (previewBorderRadius_buf__selector == (1).toChar()) {
-                previewBorderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else if (previewBorderRadius_buf__selector == (2).toChar()) {
-                previewBorderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
             }
-            else {
-                throw new Error("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.")
-            }
-            previewBorderRadius_buf = (previewBorderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
-        }
-        const previewBorderRadius_result : BorderRadiusType | undefined = previewBorderRadius_buf
-        const borderRadius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let borderRadius_buf : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-        if ((borderRadius_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const borderRadius_buf__selector : int32 = valueDeserializer.readInt8()
-            let borderRadius_buf_ : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined
-            if (borderRadius_buf__selector == (0).toChar()) {
-                const borderRadius_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let borderRadius_buf__u : string | number | Resource | undefined
-                if (borderRadius_buf__u_selector == (0).toChar()) {
-                    borderRadius_buf__u = (valueDeserializer.readString() as string)
+            const value_detents_value_1  = value_detents_value[1]
+            let value_detents_value_1_type : int32 = RuntimeType.UNDEFINED
+            value_detents_value_1_type = runtimeType(value_detents_value_1)
+            valueSerializer.writeInt8((value_detents_value_1_type).toChar())
+            if ((value_detents_value_1_type) != (RuntimeType.UNDEFINED)) {
+                const value_detents_value_1_value  = value_detents_value_1!
+                let value_detents_value_1_value_type : int32 = RuntimeType.UNDEFINED
+                value_detents_value_1_value_type = runtimeType(value_detents_value_1_value)
+                if (TypeChecker.isSheetSize(value_detents_value_1_value)) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_detents_value_1_value_0  = value_detents_value_1_value as SheetSize
+                    valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_1_value_0))
                 }
-                else if (borderRadius_buf__u_selector == (1).toChar()) {
-                    borderRadius_buf__u = (valueDeserializer.readNumber() as number)
+                else if ((RuntimeType.STRING == value_detents_value_1_value_type) || (RuntimeType.NUMBER == value_detents_value_1_value_type) || (RuntimeType.OBJECT == value_detents_value_1_value_type)) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_detents_value_1_value_1  = value_detents_value_1_value as Length
+                    let value_detents_value_1_value_1_type : int32 = RuntimeType.UNDEFINED
+                    value_detents_value_1_value_1_type = runtimeType(value_detents_value_1_value_1)
+                    if (RuntimeType.STRING == value_detents_value_1_value_1_type) {
+                        valueSerializer.writeInt8((0).toChar())
+                        const value_detents_value_1_value_1_0  = value_detents_value_1_value_1 as string
+                        valueSerializer.writeString(value_detents_value_1_value_1_0)
+                    }
+                    else if (RuntimeType.NUMBER == value_detents_value_1_value_1_type) {
+                        valueSerializer.writeInt8((1).toChar())
+                        const value_detents_value_1_value_1_1  = value_detents_value_1_value_1 as number
+                        valueSerializer.writeNumber(value_detents_value_1_value_1_1)
+                    }
+                    else if (RuntimeType.OBJECT == value_detents_value_1_value_1_type) {
+                        valueSerializer.writeInt8((2).toChar())
+                        const value_detents_value_1_value_1_2  = value_detents_value_1_value_1 as Resource
+                        Resource_serializer.write(valueSerializer, value_detents_value_1_value_1_2)
+                    }
                 }
-                else if (borderRadius_buf__u_selector == (2).toChar()) {
-                    borderRadius_buf__u = Resource_serializer.read(valueDeserializer)
+            }
+            const value_detents_value_2  = value_detents_value[2]
+            let value_detents_value_2_type : int32 = RuntimeType.UNDEFINED
+            value_detents_value_2_type = runtimeType(value_detents_value_2)
+            valueSerializer.writeInt8((value_detents_value_2_type).toChar())
+            if ((value_detents_value_2_type) != (RuntimeType.UNDEFINED)) {
+                const value_detents_value_2_value  = value_detents_value_2!
+                let value_detents_value_2_value_type : int32 = RuntimeType.UNDEFINED
+                value_detents_value_2_value_type = runtimeType(value_detents_value_2_value)
+                if (TypeChecker.isSheetSize(value_detents_value_2_value)) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_detents_value_2_value_0  = value_detents_value_2_value as SheetSize
+                    valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detents_value_2_value_0))
                 }
-                else {
-                    throw new Error("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.")
+                else if ((RuntimeType.STRING == value_detents_value_2_value_type) || (RuntimeType.NUMBER == value_detents_value_2_value_type) || (RuntimeType.OBJECT == value_detents_value_2_value_type)) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_detents_value_2_value_1  = value_detents_value_2_value as Length
+                    let value_detents_value_2_value_1_type : int32 = RuntimeType.UNDEFINED
+                    value_detents_value_2_value_1_type = runtimeType(value_detents_value_2_value_1)
+                    if (RuntimeType.STRING == value_detents_value_2_value_1_type) {
+                        valueSerializer.writeInt8((0).toChar())
+                        const value_detents_value_2_value_1_0  = value_detents_value_2_value_1 as string
+                        valueSerializer.writeString(value_detents_value_2_value_1_0)
+                    }
+                    else if (RuntimeType.NUMBER == value_detents_value_2_value_1_type) {
+                        valueSerializer.writeInt8((1).toChar())
+                        const value_detents_value_2_value_1_1  = value_detents_value_2_value_1 as number
+                        valueSerializer.writeNumber(value_detents_value_2_value_1_1)
+                    }
+                    else if (RuntimeType.OBJECT == value_detents_value_2_value_1_type) {
+                        valueSerializer.writeInt8((2).toChar())
+                        const value_detents_value_2_value_1_2  = value_detents_value_2_value_1 as Resource
+                        Resource_serializer.write(valueSerializer, value_detents_value_2_value_1_2)
+                    }
                 }
-                borderRadius_buf_ = (borderRadius_buf__u as string | number | Resource)
-            }
-            else if (borderRadius_buf__selector == (1).toChar()) {
-                borderRadius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
-            else if (borderRadius_buf__selector == (2).toChar()) {
-                borderRadius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.")
-            }
-            borderRadius_buf = (borderRadius_buf_ as Length | BorderRadiuses | LocalizedBorderRadiuses)
-        }
-        const borderRadius_result : Length | BorderRadiuses | LocalizedBorderRadiuses | undefined = borderRadius_buf
-        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onAppear_buf : (() => void) | undefined
-        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onAppear_buf = ():void => { 
-    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
-    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
-    onAppear_buf__argsSerializer.release();
-    return; }
-        }
-        const onAppear_result : (() => void) | undefined = onAppear_buf
-        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onDisappear_buf : (() => void) | undefined
-        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onDisappear_buf = ():void => { 
-    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
-    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
-    onDisappear_buf__argsSerializer.release();
-    return; }
-        }
-        const onDisappear_result : (() => void) | undefined = onDisappear_buf
-        const aboutToAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let aboutToAppear_buf : (() => void) | undefined
-        if ((aboutToAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const aboutToAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const aboutToAppear_buf__call : KPointer = valueDeserializer.readPointer()
-            const aboutToAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            aboutToAppear_buf = ():void => { 
-    const aboutToAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    aboutToAppear_buf__argsSerializer.writeInt32(aboutToAppear_buf__resource.resourceId);
-    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__call);
-    aboutToAppear_buf__argsSerializer.writePointer(aboutToAppear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, aboutToAppear_buf__argsSerializer.asBuffer(), aboutToAppear_buf__argsSerializer.length());
-    aboutToAppear_buf__argsSerializer.release();
-    return; }
-        }
-        const aboutToAppear_result : (() => void) | undefined = aboutToAppear_buf
-        const aboutToDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let aboutToDisappear_buf : (() => void) | undefined
-        if ((aboutToDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const aboutToDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const aboutToDisappear_buf__call : KPointer = valueDeserializer.readPointer()
-            const aboutToDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
-            aboutToDisappear_buf = ():void => { 
-    const aboutToDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    aboutToDisappear_buf__argsSerializer.writeInt32(aboutToDisappear_buf__resource.resourceId);
-    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__call);
-    aboutToDisappear_buf__argsSerializer.writePointer(aboutToDisappear_buf__callSync);
-    InteropNativeModule._CallCallback(-1867723152, aboutToDisappear_buf__argsSerializer.asBuffer(), aboutToDisappear_buf__argsSerializer.length());
-    aboutToDisappear_buf__argsSerializer.release();
-    return; }
-        }
-        const aboutToDisappear_result : (() => void) | undefined = aboutToDisappear_buf
-        const layoutRegionMargin_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let layoutRegionMargin_buf : Padding | undefined
-        if ((layoutRegionMargin_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            layoutRegionMargin_buf = Padding_serializer.read(valueDeserializer)
         }
-        const layoutRegionMargin_result : Padding | undefined = layoutRegionMargin_buf
-        const previewAnimationOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let previewAnimationOptions_buf : ContextMenuAnimationOptions | undefined
-        if ((previewAnimationOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            previewAnimationOptions_buf = ContextMenuAnimationOptions_serializer.read(valueDeserializer)
+        const value_blurStyle  = value.blurStyle
+        let value_blurStyle_type : int32 = RuntimeType.UNDEFINED
+        value_blurStyle_type = runtimeType(value_blurStyle)
+        valueSerializer.writeInt8((value_blurStyle_type).toChar())
+        if ((value_blurStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_blurStyle_value  = (value_blurStyle as BlurStyle)
+            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_blurStyle_value))
         }
-        const previewAnimationOptions_result : ContextMenuAnimationOptions | undefined = previewAnimationOptions_buf
-        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundColor_buf : ResourceColor | undefined
-        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let backgroundColor_buf_ : Color | number | string | Resource | undefined
-            if (backgroundColor_buf__selector == (0).toChar()) {
-                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (backgroundColor_buf__selector == (1).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
+        const value_showClose  = value.showClose
+        let value_showClose_type : int32 = RuntimeType.UNDEFINED
+        value_showClose_type = runtimeType(value_showClose)
+        valueSerializer.writeInt8((value_showClose_type).toChar())
+        if ((value_showClose_type) != (RuntimeType.UNDEFINED)) {
+            const value_showClose_value  = value_showClose!
+            let value_showClose_value_type : int32 = RuntimeType.UNDEFINED
+            value_showClose_value_type = runtimeType(value_showClose_value)
+            if (RuntimeType.BOOLEAN == value_showClose_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_showClose_value_0  = value_showClose_value as boolean
+                valueSerializer.writeBoolean(value_showClose_value_0)
             }
-            else if (backgroundColor_buf__selector == (2).toChar()) {
-                backgroundColor_buf_ = (valueDeserializer.readString() as string)
+            else if (RuntimeType.OBJECT == value_showClose_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_showClose_value_1  = value_showClose_value as Resource
+                Resource_serializer.write(valueSerializer, value_showClose_value_1)
             }
-            else if (backgroundColor_buf__selector == (3).toChar()) {
-                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
+        }
+        const value_preferType  = value.preferType
+        let value_preferType_type : int32 = RuntimeType.UNDEFINED
+        value_preferType_type = runtimeType(value_preferType)
+        valueSerializer.writeInt8((value_preferType_type).toChar())
+        if ((value_preferType_type) != (RuntimeType.UNDEFINED)) {
+            const value_preferType_value  = (value_preferType as SheetType)
+            valueSerializer.writeInt32(TypeChecker.SheetType_ToNumeric(value_preferType_value))
+        }
+        const value_title  = value.title
+        let value_title_type : int32 = RuntimeType.UNDEFINED
+        value_title_type = runtimeType(value_title)
+        valueSerializer.writeInt8((value_title_type).toChar())
+        if ((value_title_type) != (RuntimeType.UNDEFINED)) {
+            const value_title_value  = value_title!
+            let value_title_value_type : int32 = RuntimeType.UNDEFINED
+            value_title_value_type = runtimeType(value_title_value)
+            if (RuntimeType.OBJECT == value_title_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_title_value_0  = value_title_value as SheetTitleOptions
+                SheetTitleOptions_serializer.write(valueSerializer, value_title_value_0)
             }
-            else {
-                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
+            else if (RuntimeType.FUNCTION == value_title_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_title_value_1  = value_title_value as CustomBuilder
+                valueSerializer.holdAndWriteCallback(CallbackTransformer.transformFromCustomBuilder(value_title_value_1))
             }
-            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
-        }
-        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
-        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundBlurStyle_buf : BlurStyle | undefined
-        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
-        const backgroundBlurStyleOptions_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundBlurStyleOptions_buf : BackgroundBlurStyleOptions | undefined
-        if ((backgroundBlurStyleOptions_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundBlurStyleOptions_buf = BackgroundBlurStyleOptions_serializer.read(valueDeserializer)
+        const value_shouldDismiss  = value.shouldDismiss
+        let value_shouldDismiss_type : int32 = RuntimeType.UNDEFINED
+        value_shouldDismiss_type = runtimeType(value_shouldDismiss)
+        valueSerializer.writeInt8((value_shouldDismiss_type).toChar())
+        if ((value_shouldDismiss_type) != (RuntimeType.UNDEFINED)) {
+            const value_shouldDismiss_value  = value_shouldDismiss!
+            valueSerializer.holdAndWriteCallback(value_shouldDismiss_value)
         }
-        const backgroundBlurStyleOptions_result : BackgroundBlurStyleOptions | undefined = backgroundBlurStyleOptions_buf
-        const backgroundEffect_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundEffect_buf : BackgroundEffectOptions | undefined
-        if ((backgroundEffect_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundEffect_buf = BackgroundEffectOptions_serializer.read(valueDeserializer)
+        const value_onWillDismiss  = value.onWillDismiss
+        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
+        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
+        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
+        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillDismiss_value  = value_onWillDismiss!
+            valueSerializer.holdAndWriteCallback(value_onWillDismiss_value)
         }
-        const backgroundEffect_result : BackgroundEffectOptions | undefined = backgroundEffect_buf
-        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let transition_buf : TransitionEffect | undefined
-        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+        const value_onWillSpringBackWhenDismiss  = value.onWillSpringBackWhenDismiss
+        let value_onWillSpringBackWhenDismiss_type : int32 = RuntimeType.UNDEFINED
+        value_onWillSpringBackWhenDismiss_type = runtimeType(value_onWillSpringBackWhenDismiss)
+        valueSerializer.writeInt8((value_onWillSpringBackWhenDismiss_type).toChar())
+        if ((value_onWillSpringBackWhenDismiss_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWillSpringBackWhenDismiss_value  = value_onWillSpringBackWhenDismiss!
+            valueSerializer.holdAndWriteCallback(value_onWillSpringBackWhenDismiss_value)
         }
-        const transition_result : TransitionEffect | undefined = transition_buf
-        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableHoverMode_buf : boolean | undefined
-        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            enableHoverMode_buf = valueDeserializer.readBoolean()
+        const value_enableOutsideInteractive  = value.enableOutsideInteractive
+        let value_enableOutsideInteractive_type : int32 = RuntimeType.UNDEFINED
+        value_enableOutsideInteractive_type = runtimeType(value_enableOutsideInteractive)
+        valueSerializer.writeInt8((value_enableOutsideInteractive_type).toChar())
+        if ((value_enableOutsideInteractive_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableOutsideInteractive_value  = value_enableOutsideInteractive!
+            valueSerializer.writeBoolean(value_enableOutsideInteractive_value)
         }
-        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
-        const outlineColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let outlineColor_buf : ResourceColor | EdgeColors | undefined
-        if ((outlineColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const outlineColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let outlineColor_buf_ : ResourceColor | EdgeColors | undefined
-            if (outlineColor_buf__selector == (0).toChar()) {
-                const outlineColor_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let outlineColor_buf__u : Color | number | string | Resource | undefined
-                if (outlineColor_buf__u_selector == (0).toChar()) {
-                    outlineColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-                }
-                else if (outlineColor_buf__u_selector == (1).toChar()) {
-                    outlineColor_buf__u = (valueDeserializer.readNumber() as number)
-                }
-                else if (outlineColor_buf__u_selector == (2).toChar()) {
-                    outlineColor_buf__u = (valueDeserializer.readString() as string)
+        const value_width  = value.width
+        let value_width_type : int32 = RuntimeType.UNDEFINED
+        value_width_type = runtimeType(value_width)
+        valueSerializer.writeInt8((value_width_type).toChar())
+        if ((value_width_type) != (RuntimeType.UNDEFINED)) {
+            const value_width_value  = value_width!
+            let value_width_value_type : int32 = RuntimeType.UNDEFINED
+            value_width_value_type = runtimeType(value_width_value)
+            if (RuntimeType.STRING == value_width_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_width_value_0  = value_width_value as string
+                valueSerializer.writeString(value_width_value_0)
+            }
+            else if (RuntimeType.NUMBER == value_width_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_width_value_1  = value_width_value as number
+                valueSerializer.writeNumber(value_width_value_1)
+            }
+            else if (RuntimeType.OBJECT == value_width_value_type) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_width_value_2  = value_width_value as Resource
+                Resource_serializer.write(valueSerializer, value_width_value_2)
+            }
+        }
+        const value_borderWidth  = value.borderWidth
+        let value_borderWidth_type : int32 = RuntimeType.UNDEFINED
+        value_borderWidth_type = runtimeType(value_borderWidth)
+        valueSerializer.writeInt8((value_borderWidth_type).toChar())
+        if ((value_borderWidth_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderWidth_value  = value_borderWidth!
+            let value_borderWidth_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderWidth_value_type = runtimeType(value_borderWidth_value)
+            if ((RuntimeType.STRING == value_borderWidth_value_type) || (RuntimeType.NUMBER == value_borderWidth_value_type) || (RuntimeType.OBJECT == value_borderWidth_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_borderWidth_value_0  = value_borderWidth_value as Dimension
+                let value_borderWidth_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_borderWidth_value_0_type = runtimeType(value_borderWidth_value_0)
+                if (RuntimeType.STRING == value_borderWidth_value_0_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_borderWidth_value_0_0  = value_borderWidth_value_0 as string
+                    valueSerializer.writeString(value_borderWidth_value_0_0)
                 }
-                else if (outlineColor_buf__u_selector == (3).toChar()) {
-                    outlineColor_buf__u = Resource_serializer.read(valueDeserializer)
+                else if (RuntimeType.NUMBER == value_borderWidth_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_borderWidth_value_0_1  = value_borderWidth_value_0 as number
+                    valueSerializer.writeNumber(value_borderWidth_value_0_1)
                 }
-                else {
-                    throw new Error("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.")
+                else if (RuntimeType.OBJECT == value_borderWidth_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_borderWidth_value_0_2  = value_borderWidth_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_borderWidth_value_0_2)
                 }
-                outlineColor_buf_ = (outlineColor_buf__u as Color | number | string | Resource)
             }
-            else if (outlineColor_buf__selector == (1).toChar()) {
-                outlineColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
+            else if (TypeChecker.isEdgeWidths(value_borderWidth_value, true, false, true, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_borderWidth_value_1  = value_borderWidth_value as EdgeWidths
+                EdgeWidths_serializer.write(valueSerializer, value_borderWidth_value_1)
             }
-            else {
-                throw new Error("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.")
+            else if (TypeChecker.isLocalizedEdgeWidths(value_borderWidth_value, true, false, true, false)) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_borderWidth_value_2  = value_borderWidth_value as LocalizedEdgeWidths
+                LocalizedEdgeWidths_serializer.write(valueSerializer, value_borderWidth_value_2)
             }
-            outlineColor_buf = (outlineColor_buf_ as ResourceColor | EdgeColors)
         }
-        const outlineColor_result : ResourceColor | EdgeColors | undefined = outlineColor_buf
-        const outlineWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let outlineWidth_buf : Dimension | EdgeOutlineWidths | undefined
-        if ((outlineWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const outlineWidth_buf__selector : int32 = valueDeserializer.readInt8()
-            let outlineWidth_buf_ : Dimension | EdgeOutlineWidths | undefined
-            if (outlineWidth_buf__selector == (0).toChar()) {
-                const outlineWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
-                let outlineWidth_buf__u : string | number | Resource | undefined
-                if (outlineWidth_buf__u_selector == (0).toChar()) {
-                    outlineWidth_buf__u = (valueDeserializer.readString() as string)
+        const value_borderColor  = value.borderColor
+        let value_borderColor_type : int32 = RuntimeType.UNDEFINED
+        value_borderColor_type = runtimeType(value_borderColor)
+        valueSerializer.writeInt8((value_borderColor_type).toChar())
+        if ((value_borderColor_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderColor_value  = value_borderColor!
+            let value_borderColor_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderColor_value_type = runtimeType(value_borderColor_value)
+            if ((TypeChecker.isColor(value_borderColor_value)) || (RuntimeType.NUMBER == value_borderColor_value_type) || (RuntimeType.STRING == value_borderColor_value_type) || (RuntimeType.OBJECT == value_borderColor_value_type)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_borderColor_value_0  = value_borderColor_value as ResourceColor
+                let value_borderColor_value_0_type : int32 = RuntimeType.UNDEFINED
+                value_borderColor_value_0_type = runtimeType(value_borderColor_value_0)
+                if (TypeChecker.isColor(value_borderColor_value_0)) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_borderColor_value_0_0  = value_borderColor_value_0 as Color
+                    valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_borderColor_value_0_0))
                 }
-                else if (outlineWidth_buf__u_selector == (1).toChar()) {
-                    outlineWidth_buf__u = (valueDeserializer.readNumber() as number)
+                else if (RuntimeType.NUMBER == value_borderColor_value_0_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_borderColor_value_0_1  = value_borderColor_value_0 as number
+                    valueSerializer.writeNumber(value_borderColor_value_0_1)
                 }
-                else if (outlineWidth_buf__u_selector == (2).toChar()) {
-                    outlineWidth_buf__u = Resource_serializer.read(valueDeserializer)
+                else if (RuntimeType.STRING == value_borderColor_value_0_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_borderColor_value_0_2  = value_borderColor_value_0 as string
+                    valueSerializer.writeString(value_borderColor_value_0_2)
                 }
-                else {
-                    throw new Error("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.")
+                else if (RuntimeType.OBJECT == value_borderColor_value_0_type) {
+                    valueSerializer.writeInt8((3).toChar())
+                    const value_borderColor_value_0_3  = value_borderColor_value_0 as Resource
+                    Resource_serializer.write(valueSerializer, value_borderColor_value_0_3)
                 }
-                outlineWidth_buf_ = (outlineWidth_buf__u as string | number | Resource)
             }
-            else if (outlineWidth_buf__selector == (1).toChar()) {
-                outlineWidth_buf_ = EdgeOutlineWidths_serializer.read(valueDeserializer)
+            else if (TypeChecker.isEdgeColors(value_borderColor_value, true, false, true, false)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_borderColor_value_1  = value_borderColor_value as EdgeColors
+                EdgeColors_serializer.write(valueSerializer, value_borderColor_value_1)
             }
-            else {
-                throw new Error("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.")
+            else if (TypeChecker.isLocalizedEdgeColors(value_borderColor_value, true, false, true, false)) {
+                valueSerializer.writeInt8((2).toChar())
+                const value_borderColor_value_2  = value_borderColor_value as LocalizedEdgeColors
+                LocalizedEdgeColors_serializer.write(valueSerializer, value_borderColor_value_2)
             }
-            outlineWidth_buf = (outlineWidth_buf_ as Dimension | EdgeOutlineWidths)
         }
-        const outlineWidth_result : Dimension | EdgeOutlineWidths | undefined = outlineWidth_buf
-        const hapticFeedbackMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let hapticFeedbackMode_buf : HapticFeedbackMode | undefined
-        if ((hapticFeedbackMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            hapticFeedbackMode_buf = TypeChecker.HapticFeedbackMode_FromNumeric(valueDeserializer.readInt32())
-        }
-        const hapticFeedbackMode_result : HapticFeedbackMode | undefined = hapticFeedbackMode_buf
-        const title_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let title_buf : ResourceStr | undefined
-        if ((title_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            const title_buf__selector : int32 = valueDeserializer.readInt8()
-            let title_buf_ : string | Resource | undefined
-            if (title_buf__selector == (0).toChar()) {
-                title_buf_ = (valueDeserializer.readString() as string)
+        const value_borderStyle  = value.borderStyle
+        let value_borderStyle_type : int32 = RuntimeType.UNDEFINED
+        value_borderStyle_type = runtimeType(value_borderStyle)
+        valueSerializer.writeInt8((value_borderStyle_type).toChar())
+        if ((value_borderStyle_type) != (RuntimeType.UNDEFINED)) {
+            const value_borderStyle_value  = value_borderStyle!
+            let value_borderStyle_value_type : int32 = RuntimeType.UNDEFINED
+            value_borderStyle_value_type = runtimeType(value_borderStyle_value)
+            if (TypeChecker.isBorderStyle(value_borderStyle_value)) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_borderStyle_value_0  = value_borderStyle_value as BorderStyle
+                valueSerializer.writeInt32(TypeChecker.BorderStyle_ToNumeric(value_borderStyle_value_0))
             }
-            else if (title_buf__selector == (1).toChar()) {
-                title_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (RuntimeType.OBJECT == value_borderStyle_value_type) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_borderStyle_value_1  = value_borderStyle_value as EdgeStyles
+                EdgeStyles_serializer.write(valueSerializer, value_borderStyle_value_1)
             }
-            else {
-                throw new Error("One of the branches for title_buf_ has to be chosen through deserialisation.")
+        }
+        const value_shadow  = value.shadow
+        let value_shadow_type : int32 = RuntimeType.UNDEFINED
+        value_shadow_type = runtimeType(value_shadow)
+        valueSerializer.writeInt8((value_shadow_type).toChar())
+        if ((value_shadow_type) != (RuntimeType.UNDEFINED)) {
+            const value_shadow_value  = value_shadow!
+            let value_shadow_value_type : int32 = RuntimeType.UNDEFINED
+            value_shadow_value_type = runtimeType(value_shadow_value)
+            if (RuntimeType.OBJECT == value_shadow_value_type) {
+                valueSerializer.writeInt8((0).toChar())
+                const value_shadow_value_0  = value_shadow_value as ShadowOptions
+                ShadowOptions_serializer.write(valueSerializer, value_shadow_value_0)
+            }
+            else if (TypeChecker.isShadowStyle(value_shadow_value)) {
+                valueSerializer.writeInt8((1).toChar())
+                const value_shadow_value_1  = value_shadow_value as ShadowStyle
+                valueSerializer.writeInt32(TypeChecker.ShadowStyle_ToNumeric(value_shadow_value_1))
             }
-            title_buf = (title_buf_ as string | Resource)
         }
-        const title_result : ResourceStr | undefined = title_buf
-        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let showInSubWindow_buf : boolean | undefined
-        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            showInSubWindow_buf = valueDeserializer.readBoolean()
+        const value_onHeightDidChange  = value.onHeightDidChange
+        let value_onHeightDidChange_type : int32 = RuntimeType.UNDEFINED
+        value_onHeightDidChange_type = runtimeType(value_onHeightDidChange)
+        valueSerializer.writeInt8((value_onHeightDidChange_type).toChar())
+        if ((value_onHeightDidChange_type) != (RuntimeType.UNDEFINED)) {
+            const value_onHeightDidChange_value  = value_onHeightDidChange!
+            valueSerializer.holdAndWriteCallback(value_onHeightDidChange_value)
+        }
+        const value_mode  = value.mode
+        let value_mode_type : int32 = RuntimeType.UNDEFINED
+        value_mode_type = runtimeType(value_mode)
+        valueSerializer.writeInt8((value_mode_type).toChar())
+        if ((value_mode_type) != (RuntimeType.UNDEFINED)) {
+            const value_mode_value  = (value_mode as SheetMode)
+            valueSerializer.writeInt32(TypeChecker.SheetMode_ToNumeric(value_mode_value))
+        }
+        const value_scrollSizeMode  = value.scrollSizeMode
+        let value_scrollSizeMode_type : int32 = RuntimeType.UNDEFINED
+        value_scrollSizeMode_type = runtimeType(value_scrollSizeMode)
+        valueSerializer.writeInt8((value_scrollSizeMode_type).toChar())
+        if ((value_scrollSizeMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_scrollSizeMode_value  = (value_scrollSizeMode as ScrollSizeMode)
+            valueSerializer.writeInt32(TypeChecker.ScrollSizeMode_ToNumeric(value_scrollSizeMode_value))
+        }
+        const value_onDetentsDidChange  = value.onDetentsDidChange
+        let value_onDetentsDidChange_type : int32 = RuntimeType.UNDEFINED
+        value_onDetentsDidChange_type = runtimeType(value_onDetentsDidChange)
+        valueSerializer.writeInt8((value_onDetentsDidChange_type).toChar())
+        if ((value_onDetentsDidChange_type) != (RuntimeType.UNDEFINED)) {
+            const value_onDetentsDidChange_value  = value_onDetentsDidChange!
+            valueSerializer.holdAndWriteCallback(value_onDetentsDidChange_value)
+        }
+        const value_onWidthDidChange  = value.onWidthDidChange
+        let value_onWidthDidChange_type : int32 = RuntimeType.UNDEFINED
+        value_onWidthDidChange_type = runtimeType(value_onWidthDidChange)
+        valueSerializer.writeInt8((value_onWidthDidChange_type).toChar())
+        if ((value_onWidthDidChange_type) != (RuntimeType.UNDEFINED)) {
+            const value_onWidthDidChange_value  = value_onWidthDidChange!
+            valueSerializer.holdAndWriteCallback(value_onWidthDidChange_value)
+        }
+        const value_onTypeDidChange  = value.onTypeDidChange
+        let value_onTypeDidChange_type : int32 = RuntimeType.UNDEFINED
+        value_onTypeDidChange_type = runtimeType(value_onTypeDidChange)
+        valueSerializer.writeInt8((value_onTypeDidChange_type).toChar())
+        if ((value_onTypeDidChange_type) != (RuntimeType.UNDEFINED)) {
+            const value_onTypeDidChange_value  = value_onTypeDidChange!
+            valueSerializer.holdAndWriteCallback(value_onTypeDidChange_value)
+        }
+        const value_uiContext  = value.uiContext
+        let value_uiContext_type : int32 = RuntimeType.UNDEFINED
+        value_uiContext_type = runtimeType(value_uiContext)
+        valueSerializer.writeInt8((value_uiContext_type).toChar())
+        if ((value_uiContext_type) != (RuntimeType.UNDEFINED)) {
+            const value_uiContext_value  = value_uiContext!
+            UIContext_serializer.write(valueSerializer, value_uiContext_value)
+        }
+        const value_keyboardAvoidMode  = value.keyboardAvoidMode
+        let value_keyboardAvoidMode_type : int32 = RuntimeType.UNDEFINED
+        value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode)
+        valueSerializer.writeInt8((value_keyboardAvoidMode_type).toChar())
+        if ((value_keyboardAvoidMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_keyboardAvoidMode_value  = (value_keyboardAvoidMode as SheetKeyboardAvoidMode)
+            valueSerializer.writeInt32(TypeChecker.SheetKeyboardAvoidMode_ToNumeric(value_keyboardAvoidMode_value))
+        }
+        const value_enableHoverMode  = value.enableHoverMode
+        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
+        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
+        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
+        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
+            const value_enableHoverMode_value  = value_enableHoverMode!
+            valueSerializer.writeBoolean(value_enableHoverMode_value)
+        }
+        const value_hoverModeArea  = value.hoverModeArea
+        let value_hoverModeArea_type : int32 = RuntimeType.UNDEFINED
+        value_hoverModeArea_type = runtimeType(value_hoverModeArea)
+        valueSerializer.writeInt8((value_hoverModeArea_type).toChar())
+        if ((value_hoverModeArea_type) != (RuntimeType.UNDEFINED)) {
+            const value_hoverModeArea_value  = (value_hoverModeArea as HoverModeAreaType)
+            valueSerializer.writeInt32(TypeChecker.HoverModeAreaType_ToNumeric(value_hoverModeArea_value))
         }
-        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
-        let value : MenuOptions = ({offset: offset_result, placement: placement_result, enableArrow: enableArrow_result, arrowOffset: arrowOffset_result, preview: preview_result, previewBorderRadius: previewBorderRadius_result, borderRadius: borderRadius_result, onAppear: onAppear_result, onDisappear: onDisappear_result, aboutToAppear: aboutToAppear_result, aboutToDisappear: aboutToDisappear_result, layoutRegionMargin: layoutRegionMargin_result, previewAnimationOptions: previewAnimationOptions_result, backgroundColor: backgroundColor_result, backgroundBlurStyle: backgroundBlurStyle_result, backgroundBlurStyleOptions: backgroundBlurStyleOptions_result, backgroundEffect: backgroundEffect_result, transition: transition_result, enableHoverMode: enableHoverMode_result, outlineColor: outlineColor_result, outlineWidth: outlineWidth_result, hapticFeedbackMode: hapticFeedbackMode_result, title: title_result, showInSubWindow: showInSubWindow_result} as MenuOptions)
-        return value
-    }
-}
-export class PopupCommonOptions_serializer {
-    public static write(buffer: SerializerBase, value: PopupCommonOptions): void {
-        let valueSerializer : SerializerBase = buffer
-        const value_placement  = value.placement
-        let value_placement_type : int32 = RuntimeType.UNDEFINED
-        value_placement_type = runtimeType(value_placement)
-        valueSerializer.writeInt8((value_placement_type).toChar())
-        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
-            const value_placement_value  = (value_placement as Placement)
-            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+        const value_offset  = value.offset
+        let value_offset_type : int32 = RuntimeType.UNDEFINED
+        value_offset_type = runtimeType(value_offset)
+        valueSerializer.writeInt8((value_offset_type).toChar())
+        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
+            const value_offset_value  = value_offset!
+            Position_serializer.write(valueSerializer, value_offset_value)
         }
-        const value_popupColor  = value.popupColor
-        let value_popupColor_type : int32 = RuntimeType.UNDEFINED
-        value_popupColor_type = runtimeType(value_popupColor)
-        valueSerializer.writeInt8((value_popupColor_type).toChar())
-        if ((value_popupColor_type) != (RuntimeType.UNDEFINED)) {
-            const value_popupColor_value  = value_popupColor!
-            let value_popupColor_value_type : int32 = RuntimeType.UNDEFINED
-            value_popupColor_value_type = runtimeType(value_popupColor_value)
-            if (TypeChecker.isColor(value_popupColor_value)) {
+        const value_effectEdge  = value.effectEdge
+        let value_effectEdge_type : int32 = RuntimeType.UNDEFINED
+        value_effectEdge_type = runtimeType(value_effectEdge)
+        valueSerializer.writeInt8((value_effectEdge_type).toChar())
+        if ((value_effectEdge_type) != (RuntimeType.UNDEFINED)) {
+            const value_effectEdge_value  = value_effectEdge!
+            valueSerializer.writeNumber(value_effectEdge_value)
+        }
+        const value_radius  = value.radius
+        let value_radius_type : int32 = RuntimeType.UNDEFINED
+        value_radius_type = runtimeType(value_radius)
+        valueSerializer.writeInt8((value_radius_type).toChar())
+        if ((value_radius_type) != (RuntimeType.UNDEFINED)) {
+            const value_radius_value  = value_radius!
+            let value_radius_value_type : int32 = RuntimeType.UNDEFINED
+            value_radius_value_type = runtimeType(value_radius_value)
+            if (TypeChecker.isLengthMetrics(value_radius_value, false, false)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_popupColor_value_0  = value_popupColor_value as Color
-                valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_popupColor_value_0))
+                const value_radius_value_0  = value_radius_value as LengthMetrics
+                LengthMetrics_serializer.write(valueSerializer, value_radius_value_0)
             }
-            else if (RuntimeType.NUMBER == value_popupColor_value_type) {
+            else if (TypeChecker.isBorderRadiuses(value_radius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_popupColor_value_1  = value_popupColor_value as number
-                valueSerializer.writeNumber(value_popupColor_value_1)
+                const value_radius_value_1  = value_radius_value as BorderRadiuses
+                BorderRadiuses_serializer.write(valueSerializer, value_radius_value_1)
             }
-            else if (RuntimeType.STRING == value_popupColor_value_type) {
+            else if (TypeChecker.isLocalizedBorderRadiuses(value_radius_value, false, false, false, false)) {
                 valueSerializer.writeInt8((2).toChar())
-                const value_popupColor_value_2  = value_popupColor_value as string
-                valueSerializer.writeString(value_popupColor_value_2)
-            }
-            else if (RuntimeType.OBJECT == value_popupColor_value_type) {
-                valueSerializer.writeInt8((3).toChar())
-                const value_popupColor_value_3  = value_popupColor_value as Resource
-                Resource_serializer.write(valueSerializer, value_popupColor_value_3)
+                const value_radius_value_2  = value_radius_value as LocalizedBorderRadiuses
+                LocalizedBorderRadiuses_serializer.write(valueSerializer, value_radius_value_2)
             }
         }
-        const value_enableArrow  = value.enableArrow
-        let value_enableArrow_type : int32 = RuntimeType.UNDEFINED
-        value_enableArrow_type = runtimeType(value_enableArrow)
-        valueSerializer.writeInt8((value_enableArrow_type).toChar())
-        if ((value_enableArrow_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableArrow_value  = value_enableArrow!
-            valueSerializer.writeBoolean(value_enableArrow_value)
-        }
-        const value_autoCancel  = value.autoCancel
-        let value_autoCancel_type : int32 = RuntimeType.UNDEFINED
-        value_autoCancel_type = runtimeType(value_autoCancel)
-        valueSerializer.writeInt8((value_autoCancel_type).toChar())
-        if ((value_autoCancel_type) != (RuntimeType.UNDEFINED)) {
-            const value_autoCancel_value  = value_autoCancel!
-            valueSerializer.writeBoolean(value_autoCancel_value)
-        }
-        const value_onStateChange  = value.onStateChange
-        let value_onStateChange_type : int32 = RuntimeType.UNDEFINED
-        value_onStateChange_type = runtimeType(value_onStateChange)
-        valueSerializer.writeInt8((value_onStateChange_type).toChar())
-        if ((value_onStateChange_type) != (RuntimeType.UNDEFINED)) {
-            const value_onStateChange_value  = value_onStateChange!
-            valueSerializer.holdAndWriteCallback(value_onStateChange_value)
-        }
-        const value_arrowOffset  = value.arrowOffset
-        let value_arrowOffset_type : int32 = RuntimeType.UNDEFINED
-        value_arrowOffset_type = runtimeType(value_arrowOffset)
-        valueSerializer.writeInt8((value_arrowOffset_type).toChar())
-        if ((value_arrowOffset_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowOffset_value  = value_arrowOffset!
-            let value_arrowOffset_value_type : int32 = RuntimeType.UNDEFINED
-            value_arrowOffset_value_type = runtimeType(value_arrowOffset_value)
-            if (RuntimeType.STRING == value_arrowOffset_value_type) {
+        const value_detentSelection  = value.detentSelection
+        let value_detentSelection_type : int32 = RuntimeType.UNDEFINED
+        value_detentSelection_type = runtimeType(value_detentSelection)
+        valueSerializer.writeInt8((value_detentSelection_type).toChar())
+        if ((value_detentSelection_type) != (RuntimeType.UNDEFINED)) {
+            const value_detentSelection_value  = value_detentSelection!
+            let value_detentSelection_value_type : int32 = RuntimeType.UNDEFINED
+            value_detentSelection_value_type = runtimeType(value_detentSelection_value)
+            if (TypeChecker.isSheetSize(value_detentSelection_value)) {
                 valueSerializer.writeInt8((0).toChar())
-                const value_arrowOffset_value_0  = value_arrowOffset_value as string
-                valueSerializer.writeString(value_arrowOffset_value_0)
+                const value_detentSelection_value_0  = value_detentSelection_value as SheetSize
+                valueSerializer.writeInt32(TypeChecker.SheetSize_ToNumeric(value_detentSelection_value_0))
             }
-            else if (RuntimeType.NUMBER == value_arrowOffset_value_type) {
+            else if ((RuntimeType.STRING == value_detentSelection_value_type) || (RuntimeType.NUMBER == value_detentSelection_value_type) || (RuntimeType.OBJECT == value_detentSelection_value_type)) {
                 valueSerializer.writeInt8((1).toChar())
-                const value_arrowOffset_value_1  = value_arrowOffset_value as number
-                valueSerializer.writeNumber(value_arrowOffset_value_1)
-            }
-            else if (RuntimeType.OBJECT == value_arrowOffset_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_arrowOffset_value_2  = value_arrowOffset_value as Resource
-                Resource_serializer.write(valueSerializer, value_arrowOffset_value_2)
+                const value_detentSelection_value_1  = value_detentSelection_value as Length
+                let value_detentSelection_value_1_type : int32 = RuntimeType.UNDEFINED
+                value_detentSelection_value_1_type = runtimeType(value_detentSelection_value_1)
+                if (RuntimeType.STRING == value_detentSelection_value_1_type) {
+                    valueSerializer.writeInt8((0).toChar())
+                    const value_detentSelection_value_1_0  = value_detentSelection_value_1 as string
+                    valueSerializer.writeString(value_detentSelection_value_1_0)
+                }
+                else if (RuntimeType.NUMBER == value_detentSelection_value_1_type) {
+                    valueSerializer.writeInt8((1).toChar())
+                    const value_detentSelection_value_1_1  = value_detentSelection_value_1 as number
+                    valueSerializer.writeNumber(value_detentSelection_value_1_1)
+                }
+                else if (RuntimeType.OBJECT == value_detentSelection_value_1_type) {
+                    valueSerializer.writeInt8((2).toChar())
+                    const value_detentSelection_value_1_2  = value_detentSelection_value_1 as Resource
+                    Resource_serializer.write(valueSerializer, value_detentSelection_value_1_2)
+                }
             }
         }
         const value_showInSubWindow  = value.showInSubWindow
@@ -23813,556 +23767,789 @@ export class PopupCommonOptions_serializer {
             const value_showInSubWindow_value  = value_showInSubWindow!
             valueSerializer.writeBoolean(value_showInSubWindow_value)
         }
-        const value_mask  = value.mask
-        let value_mask_type : int32 = RuntimeType.UNDEFINED
-        value_mask_type = runtimeType(value_mask)
-        valueSerializer.writeInt8((value_mask_type).toChar())
-        if ((value_mask_type) != (RuntimeType.UNDEFINED)) {
-            const value_mask_value  = value_mask!
-            let value_mask_value_type : int32 = RuntimeType.UNDEFINED
-            value_mask_value_type = runtimeType(value_mask_value)
-            if (RuntimeType.BOOLEAN == value_mask_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_mask_value_0  = value_mask_value as boolean
-                valueSerializer.writeBoolean(value_mask_value_0)
+        const value_placement  = value.placement
+        let value_placement_type : int32 = RuntimeType.UNDEFINED
+        value_placement_type = runtimeType(value_placement)
+        valueSerializer.writeInt8((value_placement_type).toChar())
+        if ((value_placement_type) != (RuntimeType.UNDEFINED)) {
+            const value_placement_value  = (value_placement as Placement)
+            valueSerializer.writeInt32(TypeChecker.Placement_ToNumeric(value_placement_value))
+        }
+        const value_placementOnTarget  = value.placementOnTarget
+        let value_placementOnTarget_type : int32 = RuntimeType.UNDEFINED
+        value_placementOnTarget_type = runtimeType(value_placementOnTarget)
+        valueSerializer.writeInt8((value_placementOnTarget_type).toChar())
+        if ((value_placementOnTarget_type) != (RuntimeType.UNDEFINED)) {
+            const value_placementOnTarget_value  = value_placementOnTarget!
+            valueSerializer.writeBoolean(value_placementOnTarget_value)
+        }
+    }
+    public static read(buffer: DeserializerBase): SheetOptions {
+        let valueDeserializer : DeserializerBase = buffer
+        const backgroundColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let backgroundColor_buf : ResourceColor | undefined
+        if ((backgroundColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const backgroundColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let backgroundColor_buf_ : Color | number | string | Resource | undefined
+            if (backgroundColor_buf__selector == (0).toChar()) {
+                backgroundColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (RuntimeType.OBJECT == value_mask_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_mask_value_1  = value_mask_value as PopupMaskType
-                PopupMaskType_serializer.write(valueSerializer, value_mask_value_1)
+            else if (backgroundColor_buf__selector == (1).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-        }
-        const value_targetSpace  = value.targetSpace
-        let value_targetSpace_type : int32 = RuntimeType.UNDEFINED
-        value_targetSpace_type = runtimeType(value_targetSpace)
-        valueSerializer.writeInt8((value_targetSpace_type).toChar())
-        if ((value_targetSpace_type) != (RuntimeType.UNDEFINED)) {
-            const value_targetSpace_value  = value_targetSpace!
-            let value_targetSpace_value_type : int32 = RuntimeType.UNDEFINED
-            value_targetSpace_value_type = runtimeType(value_targetSpace_value)
-            if (RuntimeType.STRING == value_targetSpace_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_targetSpace_value_0  = value_targetSpace_value as string
-                valueSerializer.writeString(value_targetSpace_value_0)
+            else if (backgroundColor_buf__selector == (2).toChar()) {
+                backgroundColor_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (RuntimeType.NUMBER == value_targetSpace_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_targetSpace_value_1  = value_targetSpace_value as number
-                valueSerializer.writeNumber(value_targetSpace_value_1)
+            else if (backgroundColor_buf__selector == (3).toChar()) {
+                backgroundColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
-            else if (RuntimeType.OBJECT == value_targetSpace_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_targetSpace_value_2  = value_targetSpace_value as Resource
-                Resource_serializer.write(valueSerializer, value_targetSpace_value_2)
+            else {
+                throw new Error("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.")
             }
+            backgroundColor_buf = (backgroundColor_buf_ as Color | number | string | Resource)
+        }
+        const backgroundColor_result : ResourceColor | undefined = backgroundColor_buf
+        const onAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onAppear_buf : (() => void) | undefined
+        if ((onAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onAppear_buf = ():void => { 
+    const onAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onAppear_buf__argsSerializer.writeInt32(onAppear_buf__resource.resourceId);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__call);
+    onAppear_buf__argsSerializer.writePointer(onAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onAppear_buf__argsSerializer.asBuffer(), onAppear_buf__argsSerializer.length());
+    onAppear_buf__argsSerializer.release();
+    return; }
+        }
+        const onAppear_result : (() => void) | undefined = onAppear_buf
+        const onDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onDisappear_buf : (() => void) | undefined
+        if ((onDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onDisappear_buf = ():void => { 
+    const onDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onDisappear_buf__argsSerializer.writeInt32(onDisappear_buf__resource.resourceId);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__call);
+    onDisappear_buf__argsSerializer.writePointer(onDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onDisappear_buf__argsSerializer.asBuffer(), onDisappear_buf__argsSerializer.length());
+    onDisappear_buf__argsSerializer.release();
+    return; }
+        }
+        const onDisappear_result : (() => void) | undefined = onDisappear_buf
+        const onWillAppear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillAppear_buf : (() => void) | undefined
+        if ((onWillAppear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onWillAppear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillAppear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillAppear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillAppear_buf = ():void => { 
+    const onWillAppear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillAppear_buf__argsSerializer.writeInt32(onWillAppear_buf__resource.resourceId);
+    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__call);
+    onWillAppear_buf__argsSerializer.writePointer(onWillAppear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onWillAppear_buf__argsSerializer.asBuffer(), onWillAppear_buf__argsSerializer.length());
+    onWillAppear_buf__argsSerializer.release();
+    return; }
         }
-        const value_offset  = value.offset
-        let value_offset_type : int32 = RuntimeType.UNDEFINED
-        value_offset_type = runtimeType(value_offset)
-        valueSerializer.writeInt8((value_offset_type).toChar())
-        if ((value_offset_type) != (RuntimeType.UNDEFINED)) {
-            const value_offset_value  = value_offset!
-            Position_serializer.write(valueSerializer, value_offset_value)
+        const onWillAppear_result : (() => void) | undefined = onWillAppear_buf
+        const onWillDisappear_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillDisappear_buf : (() => void) | undefined
+        if ((onWillDisappear_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onWillDisappear_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillDisappear_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillDisappear_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillDisappear_buf = ():void => { 
+    const onWillDisappear_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillDisappear_buf__argsSerializer.writeInt32(onWillDisappear_buf__resource.resourceId);
+    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__call);
+    onWillDisappear_buf__argsSerializer.writePointer(onWillDisappear_buf__callSync);
+    InteropNativeModule._CallCallback(-1867723152, onWillDisappear_buf__argsSerializer.asBuffer(), onWillDisappear_buf__argsSerializer.length());
+    onWillDisappear_buf__argsSerializer.release();
+    return; }
         }
-        const value_width  = value.width
-        let value_width_type : int32 = RuntimeType.UNDEFINED
-        value_width_type = runtimeType(value_width)
-        valueSerializer.writeInt8((value_width_type).toChar())
-        if ((value_width_type) != (RuntimeType.UNDEFINED)) {
-            const value_width_value  = value_width!
-            let value_width_value_type : int32 = RuntimeType.UNDEFINED
-            value_width_value_type = runtimeType(value_width_value)
-            if (RuntimeType.STRING == value_width_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_width_value_0  = value_width_value as string
-                valueSerializer.writeString(value_width_value_0)
+        const onWillDisappear_result : (() => void) | undefined = onWillDisappear_buf
+        const height_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let height_buf : SheetSize | Length | undefined
+        if ((height_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const height_buf__selector : int32 = valueDeserializer.readInt8()
+            let height_buf_ : SheetSize | Length | undefined
+            if (height_buf__selector == (0).toChar()) {
+                height_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (RuntimeType.NUMBER == value_width_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_width_value_1  = value_width_value as number
-                valueSerializer.writeNumber(value_width_value_1)
+            else if (height_buf__selector == (1).toChar()) {
+                const height_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let height_buf__u : string | number | Resource | undefined
+                if (height_buf__u_selector == (0).toChar()) {
+                    height_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (height_buf__u_selector == (1).toChar()) {
+                    height_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (height_buf__u_selector == (2).toChar()) {
+                    height_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for height_buf__u has to be chosen through deserialisation.")
+                }
+                height_buf_ = (height_buf__u as string | number | Resource)
             }
-            else if (RuntimeType.OBJECT == value_width_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_width_value_2  = value_width_value as Resource
-                Resource_serializer.write(valueSerializer, value_width_value_2)
+            else {
+                throw new Error("One of the branches for height_buf_ has to be chosen through deserialisation.")
             }
+            height_buf = (height_buf_ as SheetSize | Length)
         }
-        const value_arrowPointPosition  = value.arrowPointPosition
-        let value_arrowPointPosition_type : int32 = RuntimeType.UNDEFINED
-        value_arrowPointPosition_type = runtimeType(value_arrowPointPosition)
-        valueSerializer.writeInt8((value_arrowPointPosition_type).toChar())
-        if ((value_arrowPointPosition_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowPointPosition_value  = (value_arrowPointPosition as ArrowPointPosition)
-            valueSerializer.writeInt32(TypeChecker.ArrowPointPosition_ToNumeric(value_arrowPointPosition_value))
+        const height_result : SheetSize | Length | undefined = height_buf
+        const dragBar_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let dragBar_buf : boolean | undefined
+        if ((dragBar_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            dragBar_buf = valueDeserializer.readBoolean()
         }
-        const value_arrowWidth  = value.arrowWidth
-        let value_arrowWidth_type : int32 = RuntimeType.UNDEFINED
-        value_arrowWidth_type = runtimeType(value_arrowWidth)
-        valueSerializer.writeInt8((value_arrowWidth_type).toChar())
-        if ((value_arrowWidth_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowWidth_value  = value_arrowWidth!
-            let value_arrowWidth_value_type : int32 = RuntimeType.UNDEFINED
-            value_arrowWidth_value_type = runtimeType(value_arrowWidth_value)
-            if (RuntimeType.STRING == value_arrowWidth_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_arrowWidth_value_0  = value_arrowWidth_value as string
-                valueSerializer.writeString(value_arrowWidth_value_0)
-            }
-            else if (RuntimeType.NUMBER == value_arrowWidth_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_arrowWidth_value_1  = value_arrowWidth_value as number
-                valueSerializer.writeNumber(value_arrowWidth_value_1)
+        const dragBar_result : boolean | undefined = dragBar_buf
+        const maskColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let maskColor_buf : ResourceColor | undefined
+        if ((maskColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const maskColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let maskColor_buf_ : Color | number | string | Resource | undefined
+            if (maskColor_buf__selector == (0).toChar()) {
+                maskColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (RuntimeType.OBJECT == value_arrowWidth_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_arrowWidth_value_2  = value_arrowWidth_value as Resource
-                Resource_serializer.write(valueSerializer, value_arrowWidth_value_2)
+            else if (maskColor_buf__selector == (1).toChar()) {
+                maskColor_buf_ = (valueDeserializer.readNumber() as number)
             }
-        }
-        const value_arrowHeight  = value.arrowHeight
-        let value_arrowHeight_type : int32 = RuntimeType.UNDEFINED
-        value_arrowHeight_type = runtimeType(value_arrowHeight)
-        valueSerializer.writeInt8((value_arrowHeight_type).toChar())
-        if ((value_arrowHeight_type) != (RuntimeType.UNDEFINED)) {
-            const value_arrowHeight_value  = value_arrowHeight!
-            let value_arrowHeight_value_type : int32 = RuntimeType.UNDEFINED
-            value_arrowHeight_value_type = runtimeType(value_arrowHeight_value)
-            if (RuntimeType.STRING == value_arrowHeight_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_arrowHeight_value_0  = value_arrowHeight_value as string
-                valueSerializer.writeString(value_arrowHeight_value_0)
+            else if (maskColor_buf__selector == (2).toChar()) {
+                maskColor_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (RuntimeType.NUMBER == value_arrowHeight_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_arrowHeight_value_1  = value_arrowHeight_value as number
-                valueSerializer.writeNumber(value_arrowHeight_value_1)
+            else if (maskColor_buf__selector == (3).toChar()) {
+                maskColor_buf_ = Resource_serializer.read(valueDeserializer)
             }
-            else if (RuntimeType.OBJECT == value_arrowHeight_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_arrowHeight_value_2  = value_arrowHeight_value as Resource
-                Resource_serializer.write(valueSerializer, value_arrowHeight_value_2)
+            else {
+                throw new Error("One of the branches for maskColor_buf_ has to be chosen through deserialisation.")
             }
+            maskColor_buf = (maskColor_buf_ as Color | number | string | Resource)
         }
-        const value_radius  = value.radius
-        let value_radius_type : int32 = RuntimeType.UNDEFINED
-        value_radius_type = runtimeType(value_radius)
-        valueSerializer.writeInt8((value_radius_type).toChar())
-        if ((value_radius_type) != (RuntimeType.UNDEFINED)) {
-            const value_radius_value  = value_radius!
-            let value_radius_value_type : int32 = RuntimeType.UNDEFINED
-            value_radius_value_type = runtimeType(value_radius_value)
-            if (RuntimeType.STRING == value_radius_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_radius_value_0  = value_radius_value as string
-                valueSerializer.writeString(value_radius_value_0)
+        const maskColor_result : ResourceColor | undefined = maskColor_buf
+        const detents_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let detents_buf : TripleLengthDetents | undefined
+        if ((detents_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const detents_buf__value0_buf_selector : int32 = valueDeserializer.readInt8()
+            let detents_buf__value0_buf : SheetSize | Length | undefined
+            if (detents_buf__value0_buf_selector == (0).toChar()) {
+                detents_buf__value0_buf = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (RuntimeType.NUMBER == value_radius_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_radius_value_1  = value_radius_value as number
-                valueSerializer.writeNumber(value_radius_value_1)
+            else if (detents_buf__value0_buf_selector == (1).toChar()) {
+                const detents_buf__value0_buf_u_selector : int32 = valueDeserializer.readInt8()
+                let detents_buf__value0_buf_u : string | number | Resource | undefined
+                if (detents_buf__value0_buf_u_selector == (0).toChar()) {
+                    detents_buf__value0_buf_u = (valueDeserializer.readString() as string)
+                }
+                else if (detents_buf__value0_buf_u_selector == (1).toChar()) {
+                    detents_buf__value0_buf_u = (valueDeserializer.readNumber() as number)
+                }
+                else if (detents_buf__value0_buf_u_selector == (2).toChar()) {
+                    detents_buf__value0_buf_u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for detents_buf__value0_buf_u has to be chosen through deserialisation.")
+                }
+                detents_buf__value0_buf = (detents_buf__value0_buf_u as string | number | Resource)
             }
-            else if (RuntimeType.OBJECT == value_radius_value_type) {
-                valueSerializer.writeInt8((2).toChar())
-                const value_radius_value_2  = value_radius_value as Resource
-                Resource_serializer.write(valueSerializer, value_radius_value_2)
+            else {
+                throw new Error("One of the branches for detents_buf__value0_buf has to be chosen through deserialisation.")
             }
-        }
-        const value_shadow  = value.shadow
-        let value_shadow_type : int32 = RuntimeType.UNDEFINED
-        value_shadow_type = runtimeType(value_shadow)
-        valueSerializer.writeInt8((value_shadow_type).toChar())
-        if ((value_shadow_type) != (RuntimeType.UNDEFINED)) {
-            const value_shadow_value  = value_shadow!
-            let value_shadow_value_type : int32 = RuntimeType.UNDEFINED
-            value_shadow_value_type = runtimeType(value_shadow_value)
-            if (RuntimeType.OBJECT == value_shadow_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_shadow_value_0  = value_shadow_value as ShadowOptions
-                ShadowOptions_serializer.write(valueSerializer, value_shadow_value_0)
+            const detents_buf__value0 : SheetSize | Length = (detents_buf__value0_buf as SheetSize | Length)
+            const detents_buf__value1_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+            let detents_buf__value1_buf : SheetSize | Length | undefined
+            if ((detents_buf__value1_buf_runtimeType) != (RuntimeType.UNDEFINED))
+            {
+                const detents_buf__value1_buf__selector : int32 = valueDeserializer.readInt8()
+                let detents_buf__value1_buf_ : SheetSize | Length | undefined
+                if (detents_buf__value1_buf__selector == (0).toChar()) {
+                    detents_buf__value1_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
+                }
+                else if (detents_buf__value1_buf__selector == (1).toChar()) {
+                    const detents_buf__value1_buf__u_selector : int32 = valueDeserializer.readInt8()
+                    let detents_buf__value1_buf__u : string | number | Resource | undefined
+                    if (detents_buf__value1_buf__u_selector == (0).toChar()) {
+                        detents_buf__value1_buf__u = (valueDeserializer.readString() as string)
+                    }
+                    else if (detents_buf__value1_buf__u_selector == (1).toChar()) {
+                        detents_buf__value1_buf__u = (valueDeserializer.readNumber() as number)
+                    }
+                    else if (detents_buf__value1_buf__u_selector == (2).toChar()) {
+                        detents_buf__value1_buf__u = Resource_serializer.read(valueDeserializer)
+                    }
+                    else {
+                        throw new Error("One of the branches for detents_buf__value1_buf__u has to be chosen through deserialisation.")
+                    }
+                    detents_buf__value1_buf_ = (detents_buf__value1_buf__u as string | number | Resource)
+                }
+                else {
+                    throw new Error("One of the branches for detents_buf__value1_buf_ has to be chosen through deserialisation.")
+                }
+                detents_buf__value1_buf = (detents_buf__value1_buf_ as SheetSize | Length)
             }
-            else if (TypeChecker.isShadowStyle(value_shadow_value)) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_shadow_value_1  = value_shadow_value as ShadowStyle
-                valueSerializer.writeInt32(TypeChecker.ShadowStyle_ToNumeric(value_shadow_value_1))
+            const detents_buf__value1 : SheetSize | Length | undefined = detents_buf__value1_buf
+            const detents_buf__value2_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+            let detents_buf__value2_buf : SheetSize | Length | undefined
+            if ((detents_buf__value2_buf_runtimeType) != (RuntimeType.UNDEFINED))
+            {
+                const detents_buf__value2_buf__selector : int32 = valueDeserializer.readInt8()
+                let detents_buf__value2_buf_ : SheetSize | Length | undefined
+                if (detents_buf__value2_buf__selector == (0).toChar()) {
+                    detents_buf__value2_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
+                }
+                else if (detents_buf__value2_buf__selector == (1).toChar()) {
+                    const detents_buf__value2_buf__u_selector : int32 = valueDeserializer.readInt8()
+                    let detents_buf__value2_buf__u : string | number | Resource | undefined
+                    if (detents_buf__value2_buf__u_selector == (0).toChar()) {
+                        detents_buf__value2_buf__u = (valueDeserializer.readString() as string)
+                    }
+                    else if (detents_buf__value2_buf__u_selector == (1).toChar()) {
+                        detents_buf__value2_buf__u = (valueDeserializer.readNumber() as number)
+                    }
+                    else if (detents_buf__value2_buf__u_selector == (2).toChar()) {
+                        detents_buf__value2_buf__u = Resource_serializer.read(valueDeserializer)
+                    }
+                    else {
+                        throw new Error("One of the branches for detents_buf__value2_buf__u has to be chosen through deserialisation.")
+                    }
+                    detents_buf__value2_buf_ = (detents_buf__value2_buf__u as string | number | Resource)
+                }
+                else {
+                    throw new Error("One of the branches for detents_buf__value2_buf_ has to be chosen through deserialisation.")
+                }
+                detents_buf__value2_buf = (detents_buf__value2_buf_ as SheetSize | Length)
             }
+            const detents_buf__value2 : SheetSize | Length | undefined = detents_buf__value2_buf
+            detents_buf = ([detents_buf__value0, detents_buf__value1, detents_buf__value2] as TripleLengthDetents)
         }
-        const value_backgroundBlurStyle  = value.backgroundBlurStyle
-        let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED
-        value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle)
-        valueSerializer.writeInt8((value_backgroundBlurStyle_type).toChar())
-        if ((value_backgroundBlurStyle_type) != (RuntimeType.UNDEFINED)) {
-            const value_backgroundBlurStyle_value  = (value_backgroundBlurStyle as BlurStyle)
-            valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value))
-        }
-        const value_focusable  = value.focusable
-        let value_focusable_type : int32 = RuntimeType.UNDEFINED
-        value_focusable_type = runtimeType(value_focusable)
-        valueSerializer.writeInt8((value_focusable_type).toChar())
-        if ((value_focusable_type) != (RuntimeType.UNDEFINED)) {
-            const value_focusable_value  = value_focusable!
-            valueSerializer.writeBoolean(value_focusable_value)
-        }
-        const value_transition  = value.transition
-        let value_transition_type : int32 = RuntimeType.UNDEFINED
-        value_transition_type = runtimeType(value_transition)
-        valueSerializer.writeInt8((value_transition_type).toChar())
-        if ((value_transition_type) != (RuntimeType.UNDEFINED)) {
-            const value_transition_value  = value_transition!
-            TransitionEffect_serializer.write(valueSerializer, value_transition_value)
+        const detents_result : TripleLengthDetents | undefined = detents_buf
+        const blurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let blurStyle_buf : BlurStyle | undefined
+        if ((blurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            blurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
         }
-        const value_onWillDismiss  = value.onWillDismiss
-        let value_onWillDismiss_type : int32 = RuntimeType.UNDEFINED
-        value_onWillDismiss_type = runtimeType(value_onWillDismiss)
-        valueSerializer.writeInt8((value_onWillDismiss_type).toChar())
-        if ((value_onWillDismiss_type) != (RuntimeType.UNDEFINED)) {
-            const value_onWillDismiss_value  = value_onWillDismiss!
-            let value_onWillDismiss_value_type : int32 = RuntimeType.UNDEFINED
-            value_onWillDismiss_value_type = runtimeType(value_onWillDismiss_value)
-            if (RuntimeType.BOOLEAN == value_onWillDismiss_value_type) {
-                valueSerializer.writeInt8((0).toChar())
-                const value_onWillDismiss_value_0  = value_onWillDismiss_value as boolean
-                valueSerializer.writeBoolean(value_onWillDismiss_value_0)
+        const blurStyle_result : BlurStyle | undefined = blurStyle_buf
+        const showClose_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let showClose_buf : boolean | Resource | undefined
+        if ((showClose_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const showClose_buf__selector : int32 = valueDeserializer.readInt8()
+            let showClose_buf_ : boolean | Resource | undefined
+            if (showClose_buf__selector == (0).toChar()) {
+                showClose_buf_ = valueDeserializer.readBoolean()
             }
-            else if (RuntimeType.FUNCTION == value_onWillDismiss_value_type) {
-                valueSerializer.writeInt8((1).toChar())
-                const value_onWillDismiss_value_1  = value_onWillDismiss_value as ((value0: DismissPopupAction) => void)
-                valueSerializer.holdAndWriteCallback(value_onWillDismiss_value_1)
+            else if (showClose_buf__selector == (1).toChar()) {
+                showClose_buf_ = Resource_serializer.read(valueDeserializer)
             }
+            else {
+                throw new Error("One of the branches for showClose_buf_ has to be chosen through deserialisation.")
+            }
+            showClose_buf = (showClose_buf_ as boolean | Resource)
         }
-        const value_enableHoverMode  = value.enableHoverMode
-        let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED
-        value_enableHoverMode_type = runtimeType(value_enableHoverMode)
-        valueSerializer.writeInt8((value_enableHoverMode_type).toChar())
-        if ((value_enableHoverMode_type) != (RuntimeType.UNDEFINED)) {
-            const value_enableHoverMode_value  = value_enableHoverMode!
-            valueSerializer.writeBoolean(value_enableHoverMode_value)
-        }
-        const value_followTransformOfTarget  = value.followTransformOfTarget
-        let value_followTransformOfTarget_type : int32 = RuntimeType.UNDEFINED
-        value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget)
-        valueSerializer.writeInt8((value_followTransformOfTarget_type).toChar())
-        if ((value_followTransformOfTarget_type) != (RuntimeType.UNDEFINED)) {
-            const value_followTransformOfTarget_value  = value_followTransformOfTarget!
-            valueSerializer.writeBoolean(value_followTransformOfTarget_value)
-        }
-    }
-    public static read(buffer: DeserializerBase): PopupCommonOptions {
-        let valueDeserializer : DeserializerBase = buffer
-        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let placement_buf : Placement | undefined
-        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const showClose_result : boolean | Resource | undefined = showClose_buf
+        const preferType_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let preferType_buf : SheetType | undefined
+        if ((preferType_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
+            preferType_buf = TypeChecker.SheetType_FromNumeric(valueDeserializer.readInt32())
         }
-        const placement_result : Placement | undefined = placement_buf
-        const popupColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let popupColor_buf : ResourceColor | undefined
-        if ((popupColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const preferType_result : SheetType | undefined = preferType_buf
+        const title_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let title_buf : SheetTitleOptions | CustomBuilder | undefined
+        if ((title_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const popupColor_buf__selector : int32 = valueDeserializer.readInt8()
-            let popupColor_buf_ : Color | number | string | Resource | undefined
-            if (popupColor_buf__selector == (0).toChar()) {
-                popupColor_buf_ = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
-            }
-            else if (popupColor_buf__selector == (1).toChar()) {
-                popupColor_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (popupColor_buf__selector == (2).toChar()) {
-                popupColor_buf_ = (valueDeserializer.readString() as string)
+            const title_buf__selector : int32 = valueDeserializer.readInt8()
+            let title_buf_ : SheetTitleOptions | CustomBuilder | undefined
+            if (title_buf__selector == (0).toChar()) {
+                title_buf_ = SheetTitleOptions_serializer.read(valueDeserializer)
             }
-            else if (popupColor_buf__selector == (3).toChar()) {
-                popupColor_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (title_buf__selector == (1).toChar()) {
+                const title_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
+                const title_buf__u_call : KPointer = valueDeserializer.readPointer()
+                const title_buf__u_callSync : KPointer = valueDeserializer.readPointer()
+                title_buf_ = ():void => { 
+    const title_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
+    title_buf__u_argsSerializer.writeInt32(title_buf__u_resource.resourceId);
+    title_buf__u_argsSerializer.writePointer(title_buf__u_call);
+    title_buf__u_argsSerializer.writePointer(title_buf__u_callSync);
+    InteropNativeModule._CallCallback(737226752, title_buf__u_argsSerializer.asBuffer(), title_buf__u_argsSerializer.length());
+    title_buf__u_argsSerializer.release();
+    return; }
             }
             else {
-                throw new Error("One of the branches for popupColor_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for title_buf_ has to be chosen through deserialisation.")
             }
-            popupColor_buf = (popupColor_buf_ as Color | number | string | Resource)
+            title_buf = (title_buf_ as SheetTitleOptions | CustomBuilder)
         }
-        const popupColor_result : ResourceColor | undefined = popupColor_buf
-        const enableArrow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableArrow_buf : boolean | undefined
-        if ((enableArrow_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const title_result : SheetTitleOptions | CustomBuilder | undefined = title_buf
+        const shouldDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let shouldDismiss_buf : ((sheetDismiss: SheetDismiss) => void) | undefined
+        if ((shouldDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            enableArrow_buf = valueDeserializer.readBoolean()
+            const shouldDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const shouldDismiss_buf__call : KPointer = valueDeserializer.readPointer()
+            const shouldDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
+            shouldDismiss_buf = (sheetDismiss: SheetDismiss):void => { 
+    const shouldDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    shouldDismiss_buf__argsSerializer.writeInt32(shouldDismiss_buf__resource.resourceId);
+    shouldDismiss_buf__argsSerializer.writePointer(shouldDismiss_buf__call);
+    shouldDismiss_buf__argsSerializer.writePointer(shouldDismiss_buf__callSync);
+    SheetDismiss_serializer.write(shouldDismiss_buf__argsSerializer, sheetDismiss);
+    InteropNativeModule._CallCallback(22609082, shouldDismiss_buf__argsSerializer.asBuffer(), shouldDismiss_buf__argsSerializer.length());
+    shouldDismiss_buf__argsSerializer.release();
+    return; }
         }
-        const enableArrow_result : boolean | undefined = enableArrow_buf
-        const autoCancel_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let autoCancel_buf : boolean | undefined
-        if ((autoCancel_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const shouldDismiss_result : ((sheetDismiss: SheetDismiss) => void) | undefined = shouldDismiss_buf
+        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillDismiss_buf : ((value0: DismissSheetAction) => void) | undefined
+        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            autoCancel_buf = valueDeserializer.readBoolean()
+            const onWillDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillDismiss_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillDismiss_buf = (value0: DismissSheetAction):void => { 
+    const onWillDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillDismiss_buf__argsSerializer.writeInt32(onWillDismiss_buf__resource.resourceId);
+    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__call);
+    onWillDismiss_buf__argsSerializer.writePointer(onWillDismiss_buf__callSync);
+    DismissSheetAction_serializer.write(onWillDismiss_buf__argsSerializer, value0);
+    InteropNativeModule._CallCallback(889549796, onWillDismiss_buf__argsSerializer.asBuffer(), onWillDismiss_buf__argsSerializer.length());
+    onWillDismiss_buf__argsSerializer.release();
+    return; }
         }
-        const autoCancel_result : boolean | undefined = autoCancel_buf
-        const onStateChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onStateChange_buf : PopupStateChangeCallback | undefined
-        if ((onStateChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const onWillDismiss_result : ((value0: DismissSheetAction) => void) | undefined = onWillDismiss_buf
+        const onWillSpringBackWhenDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWillSpringBackWhenDismiss_buf : ((value0: SpringBackAction) => void) | undefined
+        if ((onWillSpringBackWhenDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onStateChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
-            const onStateChange_buf__call : KPointer = valueDeserializer.readPointer()
-            const onStateChange_buf__callSync : KPointer = valueDeserializer.readPointer()
-            onStateChange_buf = (event: PopupStateChangeParam):void => { 
-    const onStateChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
-    onStateChange_buf__argsSerializer.writeInt32(onStateChange_buf__resource.resourceId);
-    onStateChange_buf__argsSerializer.writePointer(onStateChange_buf__call);
-    onStateChange_buf__argsSerializer.writePointer(onStateChange_buf__callSync);
-    PopupStateChangeParam_serializer.write(onStateChange_buf__argsSerializer, event);
-    InteropNativeModule._CallCallback(-1444325632, onStateChange_buf__argsSerializer.asBuffer(), onStateChange_buf__argsSerializer.length());
-    onStateChange_buf__argsSerializer.release();
+            const onWillSpringBackWhenDismiss_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWillSpringBackWhenDismiss_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWillSpringBackWhenDismiss_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWillSpringBackWhenDismiss_buf = (value0: SpringBackAction):void => { 
+    const onWillSpringBackWhenDismiss_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWillSpringBackWhenDismiss_buf__argsSerializer.writeInt32(onWillSpringBackWhenDismiss_buf__resource.resourceId);
+    onWillSpringBackWhenDismiss_buf__argsSerializer.writePointer(onWillSpringBackWhenDismiss_buf__call);
+    onWillSpringBackWhenDismiss_buf__argsSerializer.writePointer(onWillSpringBackWhenDismiss_buf__callSync);
+    SpringBackAction_serializer.write(onWillSpringBackWhenDismiss_buf__argsSerializer, value0);
+    InteropNativeModule._CallCallback(1536231691, onWillSpringBackWhenDismiss_buf__argsSerializer.asBuffer(), onWillSpringBackWhenDismiss_buf__argsSerializer.length());
+    onWillSpringBackWhenDismiss_buf__argsSerializer.release();
     return; }
         }
-        const onStateChange_result : PopupStateChangeCallback | undefined = onStateChange_buf
-        const arrowOffset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowOffset_buf : Length | undefined
-        if ((arrowOffset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const onWillSpringBackWhenDismiss_result : ((value0: SpringBackAction) => void) | undefined = onWillSpringBackWhenDismiss_buf
+        const enableOutsideInteractive_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableOutsideInteractive_buf : boolean | undefined
+        if ((enableOutsideInteractive_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const arrowOffset_buf__selector : int32 = valueDeserializer.readInt8()
-            let arrowOffset_buf_ : string | number | Resource | undefined
-            if (arrowOffset_buf__selector == (0).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (arrowOffset_buf__selector == (1).toChar()) {
-                arrowOffset_buf_ = (valueDeserializer.readNumber() as number)
+            enableOutsideInteractive_buf = valueDeserializer.readBoolean()
+        }
+        const enableOutsideInteractive_result : boolean | undefined = enableOutsideInteractive_buf
+        const width_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let width_buf : Dimension | undefined
+        if ((width_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const width_buf__selector : int32 = valueDeserializer.readInt8()
+            let width_buf_ : string | number | Resource | undefined
+            if (width_buf__selector == (0).toChar()) {
+                width_buf_ = (valueDeserializer.readString() as string)
             }
-            else if (arrowOffset_buf__selector == (2).toChar()) {
-                arrowOffset_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (width_buf__selector == (1).toChar()) {
+                width_buf_ = (valueDeserializer.readNumber() as number)
+            }
+            else if (width_buf__selector == (2).toChar()) {
+                width_buf_ = Resource_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for width_buf_ has to be chosen through deserialisation.")
             }
-            arrowOffset_buf = (arrowOffset_buf_ as string | number | Resource)
-        }
-        const arrowOffset_result : Length | undefined = arrowOffset_buf
-        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let showInSubWindow_buf : boolean | undefined
-        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            showInSubWindow_buf = valueDeserializer.readBoolean()
+            width_buf = (width_buf_ as string | number | Resource)
         }
-        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
-        const mask_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let mask_buf : boolean | PopupMaskType | undefined
-        if ((mask_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const width_result : Dimension | undefined = width_buf
+        const borderWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let borderWidth_buf : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined
+        if ((borderWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const mask_buf__selector : int32 = valueDeserializer.readInt8()
-            let mask_buf_ : boolean | PopupMaskType | undefined
-            if (mask_buf__selector == (0).toChar()) {
-                mask_buf_ = valueDeserializer.readBoolean()
+            const borderWidth_buf__selector : int32 = valueDeserializer.readInt8()
+            let borderWidth_buf_ : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined
+            if (borderWidth_buf__selector == (0).toChar()) {
+                const borderWidth_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let borderWidth_buf__u : string | number | Resource | undefined
+                if (borderWidth_buf__u_selector == (0).toChar()) {
+                    borderWidth_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (borderWidth_buf__u_selector == (1).toChar()) {
+                    borderWidth_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (borderWidth_buf__u_selector == (2).toChar()) {
+                    borderWidth_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.")
+                }
+                borderWidth_buf_ = (borderWidth_buf__u as string | number | Resource)
             }
-            else if (mask_buf__selector == (1).toChar()) {
-                mask_buf_ = PopupMaskType_serializer.read(valueDeserializer)
+            else if (borderWidth_buf__selector == (1).toChar()) {
+                borderWidth_buf_ = EdgeWidths_serializer.read(valueDeserializer)
+            }
+            else if (borderWidth_buf__selector == (2).toChar()) {
+                borderWidth_buf_ = LocalizedEdgeWidths_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for mask_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.")
             }
-            mask_buf = (mask_buf_ as boolean | PopupMaskType)
+            borderWidth_buf = (borderWidth_buf_ as Dimension | EdgeWidths | LocalizedEdgeWidths)
         }
-        const mask_result : boolean | PopupMaskType | undefined = mask_buf
-        const targetSpace_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let targetSpace_buf : Length | undefined
-        if ((targetSpace_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderWidth_result : Dimension | EdgeWidths | LocalizedEdgeWidths | undefined = borderWidth_buf
+        const borderColor_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let borderColor_buf : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined
+        if ((borderColor_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const targetSpace_buf__selector : int32 = valueDeserializer.readInt8()
-            let targetSpace_buf_ : string | number | Resource | undefined
-            if (targetSpace_buf__selector == (0).toChar()) {
-                targetSpace_buf_ = (valueDeserializer.readString() as string)
+            const borderColor_buf__selector : int32 = valueDeserializer.readInt8()
+            let borderColor_buf_ : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined
+            if (borderColor_buf__selector == (0).toChar()) {
+                const borderColor_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let borderColor_buf__u : Color | number | string | Resource | undefined
+                if (borderColor_buf__u_selector == (0).toChar()) {
+                    borderColor_buf__u = TypeChecker.Color_FromNumeric(valueDeserializer.readInt32())
+                }
+                else if (borderColor_buf__u_selector == (1).toChar()) {
+                    borderColor_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (borderColor_buf__u_selector == (2).toChar()) {
+                    borderColor_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (borderColor_buf__u_selector == (3).toChar()) {
+                    borderColor_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for borderColor_buf__u has to be chosen through deserialisation.")
+                }
+                borderColor_buf_ = (borderColor_buf__u as Color | number | string | Resource)
             }
-            else if (targetSpace_buf__selector == (1).toChar()) {
-                targetSpace_buf_ = (valueDeserializer.readNumber() as number)
+            else if (borderColor_buf__selector == (1).toChar()) {
+                borderColor_buf_ = EdgeColors_serializer.read(valueDeserializer)
             }
-            else if (targetSpace_buf__selector == (2).toChar()) {
-                targetSpace_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (borderColor_buf__selector == (2).toChar()) {
+                borderColor_buf_ = LocalizedEdgeColors_serializer.read(valueDeserializer)
             }
             else {
-                throw new Error("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for borderColor_buf_ has to be chosen through deserialisation.")
             }
-            targetSpace_buf = (targetSpace_buf_ as string | number | Resource)
+            borderColor_buf = (borderColor_buf_ as ResourceColor | EdgeColors | LocalizedEdgeColors)
         }
-        const targetSpace_result : Length | undefined = targetSpace_buf
-        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let offset_buf : Position | undefined
-        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderColor_result : ResourceColor | EdgeColors | LocalizedEdgeColors | undefined = borderColor_buf
+        const borderStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let borderStyle_buf : BorderStyle | EdgeStyles | undefined
+        if ((borderStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            offset_buf = Position_serializer.read(valueDeserializer)
+            const borderStyle_buf__selector : int32 = valueDeserializer.readInt8()
+            let borderStyle_buf_ : BorderStyle | EdgeStyles | undefined
+            if (borderStyle_buf__selector == (0).toChar()) {
+                borderStyle_buf_ = TypeChecker.BorderStyle_FromNumeric(valueDeserializer.readInt32())
+            }
+            else if (borderStyle_buf__selector == (1).toChar()) {
+                borderStyle_buf_ = EdgeStyles_serializer.read(valueDeserializer)
+            }
+            else {
+                throw new Error("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.")
+            }
+            borderStyle_buf = (borderStyle_buf_ as BorderStyle | EdgeStyles)
         }
-        const offset_result : Position | undefined = offset_buf
-        const width_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let width_buf : Dimension | undefined
-        if ((width_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const borderStyle_result : BorderStyle | EdgeStyles | undefined = borderStyle_buf
+        const shadow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let shadow_buf : ShadowOptions | ShadowStyle | undefined
+        if ((shadow_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const width_buf__selector : int32 = valueDeserializer.readInt8()
-            let width_buf_ : string | number | Resource | undefined
-            if (width_buf__selector == (0).toChar()) {
-                width_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (width_buf__selector == (1).toChar()) {
-                width_buf_ = (valueDeserializer.readNumber() as number)
+            const shadow_buf__selector : int32 = valueDeserializer.readInt8()
+            let shadow_buf_ : ShadowOptions | ShadowStyle | undefined
+            if (shadow_buf__selector == (0).toChar()) {
+                shadow_buf_ = ShadowOptions_serializer.read(valueDeserializer)
             }
-            else if (width_buf__selector == (2).toChar()) {
-                width_buf_ = Resource_serializer.read(valueDeserializer)
+            else if (shadow_buf__selector == (1).toChar()) {
+                shadow_buf_ = TypeChecker.ShadowStyle_FromNumeric(valueDeserializer.readInt32())
             }
             else {
-                throw new Error("One of the branches for width_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for shadow_buf_ has to be chosen through deserialisation.")
             }
-            width_buf = (width_buf_ as string | number | Resource)
+            shadow_buf = (shadow_buf_ as ShadowOptions | ShadowStyle)
+        }
+        const shadow_result : ShadowOptions | ShadowStyle | undefined = shadow_buf
+        const onHeightDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onHeightDidChange_buf : ((value0: number) => void) | undefined
+        if ((onHeightDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onHeightDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onHeightDidChange_buf__call : KPointer = valueDeserializer.readPointer()
+            const onHeightDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onHeightDidChange_buf = (value0: number):void => { 
+    const onHeightDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onHeightDidChange_buf__argsSerializer.writeInt32(onHeightDidChange_buf__resource.resourceId);
+    onHeightDidChange_buf__argsSerializer.writePointer(onHeightDidChange_buf__call);
+    onHeightDidChange_buf__argsSerializer.writePointer(onHeightDidChange_buf__callSync);
+    onHeightDidChange_buf__argsSerializer.writeNumber(value0);
+    InteropNativeModule._CallCallback(36519084, onHeightDidChange_buf__argsSerializer.asBuffer(), onHeightDidChange_buf__argsSerializer.length());
+    onHeightDidChange_buf__argsSerializer.release();
+    return; }
+        }
+        const onHeightDidChange_result : ((value0: number) => void) | undefined = onHeightDidChange_buf
+        const mode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let mode_buf : SheetMode | undefined
+        if ((mode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            mode_buf = TypeChecker.SheetMode_FromNumeric(valueDeserializer.readInt32())
+        }
+        const mode_result : SheetMode | undefined = mode_buf
+        const scrollSizeMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let scrollSizeMode_buf : ScrollSizeMode | undefined
+        if ((scrollSizeMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            scrollSizeMode_buf = TypeChecker.ScrollSizeMode_FromNumeric(valueDeserializer.readInt32())
+        }
+        const scrollSizeMode_result : ScrollSizeMode | undefined = scrollSizeMode_buf
+        const onDetentsDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onDetentsDidChange_buf : ((value0: number) => void) | undefined
+        if ((onDetentsDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onDetentsDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onDetentsDidChange_buf__call : KPointer = valueDeserializer.readPointer()
+            const onDetentsDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onDetentsDidChange_buf = (value0: number):void => { 
+    const onDetentsDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onDetentsDidChange_buf__argsSerializer.writeInt32(onDetentsDidChange_buf__resource.resourceId);
+    onDetentsDidChange_buf__argsSerializer.writePointer(onDetentsDidChange_buf__call);
+    onDetentsDidChange_buf__argsSerializer.writePointer(onDetentsDidChange_buf__callSync);
+    onDetentsDidChange_buf__argsSerializer.writeNumber(value0);
+    InteropNativeModule._CallCallback(36519084, onDetentsDidChange_buf__argsSerializer.asBuffer(), onDetentsDidChange_buf__argsSerializer.length());
+    onDetentsDidChange_buf__argsSerializer.release();
+    return; }
+        }
+        const onDetentsDidChange_result : ((value0: number) => void) | undefined = onDetentsDidChange_buf
+        const onWidthDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onWidthDidChange_buf : ((value0: number) => void) | undefined
+        if ((onWidthDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onWidthDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onWidthDidChange_buf__call : KPointer = valueDeserializer.readPointer()
+            const onWidthDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onWidthDidChange_buf = (value0: number):void => { 
+    const onWidthDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onWidthDidChange_buf__argsSerializer.writeInt32(onWidthDidChange_buf__resource.resourceId);
+    onWidthDidChange_buf__argsSerializer.writePointer(onWidthDidChange_buf__call);
+    onWidthDidChange_buf__argsSerializer.writePointer(onWidthDidChange_buf__callSync);
+    onWidthDidChange_buf__argsSerializer.writeNumber(value0);
+    InteropNativeModule._CallCallback(36519084, onWidthDidChange_buf__argsSerializer.asBuffer(), onWidthDidChange_buf__argsSerializer.length());
+    onWidthDidChange_buf__argsSerializer.release();
+    return; }
+        }
+        const onWidthDidChange_result : ((value0: number) => void) | undefined = onWidthDidChange_buf
+        const onTypeDidChange_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let onTypeDidChange_buf : ((value0: SheetType) => void) | undefined
+        if ((onTypeDidChange_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            const onTypeDidChange_buf__resource : CallbackResource = valueDeserializer.readCallbackResource()
+            const onTypeDidChange_buf__call : KPointer = valueDeserializer.readPointer()
+            const onTypeDidChange_buf__callSync : KPointer = valueDeserializer.readPointer()
+            onTypeDidChange_buf = (value0: SheetType):void => { 
+    const onTypeDidChange_buf__argsSerializer : SerializerBase = SerializerBase.hold();
+    onTypeDidChange_buf__argsSerializer.writeInt32(onTypeDidChange_buf__resource.resourceId);
+    onTypeDidChange_buf__argsSerializer.writePointer(onTypeDidChange_buf__call);
+    onTypeDidChange_buf__argsSerializer.writePointer(onTypeDidChange_buf__callSync);
+    onTypeDidChange_buf__argsSerializer.writeInt32(TypeChecker.SheetType_ToNumeric(value0));
+    InteropNativeModule._CallCallback(-224451112, onTypeDidChange_buf__argsSerializer.asBuffer(), onTypeDidChange_buf__argsSerializer.length());
+    onTypeDidChange_buf__argsSerializer.release();
+    return; }
+        }
+        const onTypeDidChange_result : ((value0: SheetType) => void) | undefined = onTypeDidChange_buf
+        const uiContext_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let uiContext_buf : UIContext | undefined
+        if ((uiContext_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            uiContext_buf = (UIContext_serializer.read(valueDeserializer) as UIContext)
+        }
+        const uiContext_result : UIContext | undefined = uiContext_buf
+        const keyboardAvoidMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let keyboardAvoidMode_buf : SheetKeyboardAvoidMode | undefined
+        if ((keyboardAvoidMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            keyboardAvoidMode_buf = TypeChecker.SheetKeyboardAvoidMode_FromNumeric(valueDeserializer.readInt32())
+        }
+        const keyboardAvoidMode_result : SheetKeyboardAvoidMode | undefined = keyboardAvoidMode_buf
+        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let enableHoverMode_buf : boolean | undefined
+        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        {
+            enableHoverMode_buf = valueDeserializer.readBoolean()
         }
-        const width_result : Dimension | undefined = width_buf
-        const arrowPointPosition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowPointPosition_buf : ArrowPointPosition | undefined
-        if ((arrowPointPosition_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
+        const hoverModeArea_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let hoverModeArea_buf : HoverModeAreaType | undefined
+        if ((hoverModeArea_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            arrowPointPosition_buf = TypeChecker.ArrowPointPosition_FromNumeric(valueDeserializer.readInt32())
+            hoverModeArea_buf = TypeChecker.HoverModeAreaType_FromNumeric(valueDeserializer.readInt32())
         }
-        const arrowPointPosition_result : ArrowPointPosition | undefined = arrowPointPosition_buf
-        const arrowWidth_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowWidth_buf : Dimension | undefined
-        if ((arrowWidth_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const hoverModeArea_result : HoverModeAreaType | undefined = hoverModeArea_buf
+        const offset_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let offset_buf : Position | undefined
+        if ((offset_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const arrowWidth_buf__selector : int32 = valueDeserializer.readInt8()
-            let arrowWidth_buf_ : string | number | Resource | undefined
-            if (arrowWidth_buf__selector == (0).toChar()) {
-                arrowWidth_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (arrowWidth_buf__selector == (1).toChar()) {
-                arrowWidth_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (arrowWidth_buf__selector == (2).toChar()) {
-                arrowWidth_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.")
-            }
-            arrowWidth_buf = (arrowWidth_buf_ as string | number | Resource)
+            offset_buf = Position_serializer.read(valueDeserializer)
         }
-        const arrowWidth_result : Dimension | undefined = arrowWidth_buf
-        const arrowHeight_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let arrowHeight_buf : Dimension | undefined
-        if ((arrowHeight_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const offset_result : Position | undefined = offset_buf
+        const effectEdge_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let effectEdge_buf : number | undefined
+        if ((effectEdge_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const arrowHeight_buf__selector : int32 = valueDeserializer.readInt8()
-            let arrowHeight_buf_ : string | number | Resource | undefined
-            if (arrowHeight_buf__selector == (0).toChar()) {
-                arrowHeight_buf_ = (valueDeserializer.readString() as string)
-            }
-            else if (arrowHeight_buf__selector == (1).toChar()) {
-                arrowHeight_buf_ = (valueDeserializer.readNumber() as number)
-            }
-            else if (arrowHeight_buf__selector == (2).toChar()) {
-                arrowHeight_buf_ = Resource_serializer.read(valueDeserializer)
-            }
-            else {
-                throw new Error("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.")
-            }
-            arrowHeight_buf = (arrowHeight_buf_ as string | number | Resource)
+            effectEdge_buf = (valueDeserializer.readNumber() as number)
         }
-        const arrowHeight_result : Dimension | undefined = arrowHeight_buf
+        const effectEdge_result : number | undefined = effectEdge_buf
         const radius_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let radius_buf : Dimension | undefined
+        let radius_buf : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined
         if ((radius_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
             const radius_buf__selector : int32 = valueDeserializer.readInt8()
-            let radius_buf_ : string | number | Resource | undefined
+            let radius_buf_ : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined
             if (radius_buf__selector == (0).toChar()) {
-                radius_buf_ = (valueDeserializer.readString() as string)
+                radius_buf_ = (LengthMetrics_serializer.read(valueDeserializer) as LengthMetrics)
             }
             else if (radius_buf__selector == (1).toChar()) {
-                radius_buf_ = (valueDeserializer.readNumber() as number)
+                radius_buf_ = BorderRadiuses_serializer.read(valueDeserializer)
             }
             else if (radius_buf__selector == (2).toChar()) {
-                radius_buf_ = Resource_serializer.read(valueDeserializer)
+                radius_buf_ = LocalizedBorderRadiuses_serializer.read(valueDeserializer)
             }
             else {
                 throw new Error("One of the branches for radius_buf_ has to be chosen through deserialisation.")
             }
-            radius_buf = (radius_buf_ as string | number | Resource)
+            radius_buf = (radius_buf_ as LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses)
         }
-        const radius_result : Dimension | undefined = radius_buf
-        const shadow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let shadow_buf : ShadowOptions | ShadowStyle | undefined
-        if ((shadow_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const radius_result : LengthMetrics | BorderRadiuses | LocalizedBorderRadiuses | undefined = radius_buf
+        const detentSelection_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let detentSelection_buf : SheetSize | Length | undefined
+        if ((detentSelection_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const shadow_buf__selector : int32 = valueDeserializer.readInt8()
-            let shadow_buf_ : ShadowOptions | ShadowStyle | undefined
-            if (shadow_buf__selector == (0).toChar()) {
-                shadow_buf_ = ShadowOptions_serializer.read(valueDeserializer)
+            const detentSelection_buf__selector : int32 = valueDeserializer.readInt8()
+            let detentSelection_buf_ : SheetSize | Length | undefined
+            if (detentSelection_buf__selector == (0).toChar()) {
+                detentSelection_buf_ = TypeChecker.SheetSize_FromNumeric(valueDeserializer.readInt32())
             }
-            else if (shadow_buf__selector == (1).toChar()) {
-                shadow_buf_ = TypeChecker.ShadowStyle_FromNumeric(valueDeserializer.readInt32())
+            else if (detentSelection_buf__selector == (1).toChar()) {
+                const detentSelection_buf__u_selector : int32 = valueDeserializer.readInt8()
+                let detentSelection_buf__u : string | number | Resource | undefined
+                if (detentSelection_buf__u_selector == (0).toChar()) {
+                    detentSelection_buf__u = (valueDeserializer.readString() as string)
+                }
+                else if (detentSelection_buf__u_selector == (1).toChar()) {
+                    detentSelection_buf__u = (valueDeserializer.readNumber() as number)
+                }
+                else if (detentSelection_buf__u_selector == (2).toChar()) {
+                    detentSelection_buf__u = Resource_serializer.read(valueDeserializer)
+                }
+                else {
+                    throw new Error("One of the branches for detentSelection_buf__u has to be chosen through deserialisation.")
+                }
+                detentSelection_buf_ = (detentSelection_buf__u as string | number | Resource)
             }
             else {
-                throw new Error("One of the branches for shadow_buf_ has to be chosen through deserialisation.")
+                throw new Error("One of the branches for detentSelection_buf_ has to be chosen through deserialisation.")
             }
-            shadow_buf = (shadow_buf_ as ShadowOptions | ShadowStyle)
-        }
-        const shadow_result : ShadowOptions | ShadowStyle | undefined = shadow_buf
-        const backgroundBlurStyle_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let backgroundBlurStyle_buf : BlurStyle | undefined
-        if ((backgroundBlurStyle_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            backgroundBlurStyle_buf = TypeChecker.BlurStyle_FromNumeric(valueDeserializer.readInt32())
-        }
-        const backgroundBlurStyle_result : BlurStyle | undefined = backgroundBlurStyle_buf
-        const focusable_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let focusable_buf : boolean | undefined
-        if ((focusable_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            focusable_buf = valueDeserializer.readBoolean()
-        }
-        const focusable_result : boolean | undefined = focusable_buf
-        const transition_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let transition_buf : TransitionEffect | undefined
-        if ((transition_buf_runtimeType) != (RuntimeType.UNDEFINED))
-        {
-            transition_buf = (TransitionEffect_serializer.read(valueDeserializer) as TransitionEffect)
+            detentSelection_buf = (detentSelection_buf_ as SheetSize | Length)
         }
-        const transition_result : TransitionEffect | undefined = transition_buf
-        const onWillDismiss_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let onWillDismiss_buf : boolean | ((value0: DismissPopupAction) => void) | undefined
-        if ((onWillDismiss_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const detentSelection_result : SheetSize | Length | undefined = detentSelection_buf
+        const showInSubWindow_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let showInSubWindow_buf : boolean | undefined
+        if ((showInSubWindow_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            const onWillDismiss_buf__selector : int32 = valueDeserializer.readInt8()
-            let onWillDismiss_buf_ : boolean | ((value0: DismissPopupAction) => void) | undefined
-            if (onWillDismiss_buf__selector == (0).toChar()) {
-                onWillDismiss_buf_ = valueDeserializer.readBoolean()
-            }
-            else if (onWillDismiss_buf__selector == (1).toChar()) {
-                const onWillDismiss_buf__u_resource : CallbackResource = valueDeserializer.readCallbackResource()
-                const onWillDismiss_buf__u_call : KPointer = valueDeserializer.readPointer()
-                const onWillDismiss_buf__u_callSync : KPointer = valueDeserializer.readPointer()
-                onWillDismiss_buf_ = (value0: DismissPopupAction):void => { 
-    const onWillDismiss_buf__u_argsSerializer : SerializerBase = SerializerBase.hold();
-    onWillDismiss_buf__u_argsSerializer.writeInt32(onWillDismiss_buf__u_resource.resourceId);
-    onWillDismiss_buf__u_argsSerializer.writePointer(onWillDismiss_buf__u_call);
-    onWillDismiss_buf__u_argsSerializer.writePointer(onWillDismiss_buf__u_callSync);
-    DismissPopupAction_serializer.write(onWillDismiss_buf__u_argsSerializer, value0);
-    InteropNativeModule._CallCallback(-2004166751, onWillDismiss_buf__u_argsSerializer.asBuffer(), onWillDismiss_buf__u_argsSerializer.length());
-    onWillDismiss_buf__u_argsSerializer.release();
-    return; }
-            }
-            else {
-                throw new Error("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.")
-            }
-            onWillDismiss_buf = (onWillDismiss_buf_ as boolean | ((value0: DismissPopupAction) => void))
+            showInSubWindow_buf = valueDeserializer.readBoolean()
         }
-        const onWillDismiss_result : boolean | ((value0: DismissPopupAction) => void) | undefined = onWillDismiss_buf
-        const enableHoverMode_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let enableHoverMode_buf : boolean | undefined
-        if ((enableHoverMode_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const showInSubWindow_result : boolean | undefined = showInSubWindow_buf
+        const placement_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let placement_buf : Placement | undefined
+        if ((placement_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            enableHoverMode_buf = valueDeserializer.readBoolean()
+            placement_buf = TypeChecker.Placement_FromNumeric(valueDeserializer.readInt32())
         }
-        const enableHoverMode_result : boolean | undefined = enableHoverMode_buf
-        const followTransformOfTarget_buf_runtimeType  = valueDeserializer.readInt8().toInt()
-        let followTransformOfTarget_buf : boolean | undefined
-        if ((followTransformOfTarget_buf_runtimeType) != (RuntimeType.UNDEFINED))
+        const placement_result : Placement | undefined = placement_buf
+        const placementOnTarget_buf_runtimeType  = valueDeserializer.readInt8().toInt()
+        let placementOnTarget_buf : boolean | undefined
+        if ((placementOnTarget_buf_runtimeType) != (RuntimeType.UNDEFINED))
         {
-            followTransformOfTarget_buf = valueDeserializer.readBoolean()
+            placementOnTarget_buf = valueDeserializer.readBoolean()
         }
-        const followTransformOfTarget_result : boolean | undefined = followTransformOfTarget_buf
-        let value : PopupCommonOptions = ({placement: placement_result, popupColor: popupColor_result, enableArrow: enableArrow_result, autoCancel: autoCancel_result, onStateChange: onStateChange_result, arrowOffset: arrowOffset_result, showInSubWindow: showInSubWindow_result, mask: mask_result, targetSpace: targetSpace_result, offset: offset_result, width: width_result, arrowPointPosition: arrowPointPosition_result, arrowWidth: arrowWidth_result, arrowHeight: arrowHeight_result, radius: radius_result, shadow: shadow_result, backgroundBlurStyle: backgroundBlurStyle_result, focusable: focusable_result, transition: transition_result, onWillDismiss: onWillDismiss_result, enableHoverMode: enableHoverMode_result, followTransformOfTarget: followTransformOfTarget_result} as PopupCommonOptions)
+        const placementOnTarget_result : boolean | undefined = placementOnTarget_buf
+        let value : SheetOptions = ({backgroundColor: backgroundColor_result, onAppear: onAppear_result, onDisappear: onDisappear_result, onWillAppear: onWillAppear_result, onWillDisappear: onWillDisappear_result, height: height_result, dragBar: dragBar_result, maskColor: maskColor_result, detents: detents_result, blurStyle: blurStyle_result, showClose: showClose_result, preferType: preferType_result, title: title_result, shouldDismiss: shouldDismiss_result, onWillDismiss: onWillDismiss_result, onWillSpringBackWhenDismiss: onWillSpringBackWhenDismiss_result, enableOutsideInteractive: enableOutsideInteractive_result, width: width_result, borderWidth: borderWidth_result, borderColor: borderColor_result, borderStyle: borderStyle_result, shadow: shadow_result, onHeightDidChange: onHeightDidChange_result, mode: mode_result, scrollSizeMode: scrollSizeMode_result, onDetentsDidChange: onDetentsDidChange_result, onWidthDidChange: onWidthDidChange_result, onTypeDidChange: onTypeDidChange_result, uiContext: uiContext_result, keyboardAvoidMode: keyboardAvoidMode_result, enableHoverMode: enableHoverMode_result, hoverModeArea: hoverModeArea_result, offset: offset_result, effectEdge: effectEdge_result, radius: radius_result, detentSelection: detentSelection_result, showInSubWindow: showInSubWindow_result, placement: placement_result, placementOnTarget: placementOnTarget_result} as SheetOptions)
         return value
     }
 }
+export class TouchEvent_serializer {
+    public static write(buffer: SerializerBase, value: TouchEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): TouchEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return TouchEventInternal.fromPtr(ptr)
+    }
+}
+export class AccessibilityHoverEvent_serializer {
+    public static write(buffer: SerializerBase, value: AccessibilityHoverEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): AccessibilityHoverEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return AccessibilityHoverEventInternal.fromPtr(ptr)
+    }
+}
+export class AxisEvent_serializer {
+    public static write(buffer: SerializerBase, value: AxisEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): AxisEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return AxisEventInternal.fromPtr(ptr)
+    }
+}
+export class BaseEvent_serializer {
+    public static write(buffer: SerializerBase, value: BaseEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): BaseEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return BaseEventInternal.fromPtr(ptr)
+    }
+}
+export class ClickEvent_serializer {
+    public static write(buffer: SerializerBase, value: ClickEvent): void {
+        let valueSerializer : SerializerBase = buffer
+        valueSerializer.writePointer(toPeerPtr(value))
+    }
+    public static read(buffer: DeserializerBase): ClickEvent {
+        let valueDeserializer : DeserializerBase = buffer
+        let ptr : KPointer = valueDeserializer.readPointer()
+        return ClickEventInternal.fromPtr(ptr)
+    }
+}
 export class PopupOptions_serializer {
     public static write(buffer: SerializerBase, value: PopupOptions): void {
         let valueSerializer : SerializerBase = buffer
@@ -25057,17 +25244,6 @@ export class PopupOptions_serializer {
         return value
     }
 }
-export class TransitionEffect_serializer {
-    public static write(buffer: SerializerBase, value: TransitionEffect): void {
-        let valueSerializer : SerializerBase = buffer
-        valueSerializer.writePointer(toPeerPtr(value))
-    }
-    public static read(buffer: DeserializerBase): TransitionEffect {
-        let valueDeserializer : DeserializerBase = buffer
-        let ptr : KPointer = valueDeserializer.readPointer()
-        return TransitionEffectInternal.fromPtr(ptr)
-    }
-}
 export interface AccessibilityHoverEvent {
     type: AccessibilityHoverType
     x: number
diff --git a/arkoala-arkts/arkui/src/generated/arkts/ArkUIGeneratedNativeModule.ets b/arkoala-arkts/arkui/src/generated/arkts/ArkUIGeneratedNativeModule.ets
index cbb8421a82..2659db043e 100644
--- a/arkoala-arkts/arkui/src/generated/arkts/ArkUIGeneratedNativeModule.ets
+++ b/arkoala-arkts/arkui/src/generated/arkts/ArkUIGeneratedNativeModule.ets
@@ -161,6 +161,36 @@ export class ArkUIGeneratedNativeModule {
     @ani.unsafe.Direct
     native static _ButtonAttribute_setMaxFontScale(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
     @ani.unsafe.Direct
+    native static _Calendar_construct(id: KInt, flags: KInt): KPointer
+    @ani.unsafe.Direct
+    native static _CalendarInterface_setCalendarOptions(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setShowLunar(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setShowHoliday(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setNeedSlide(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setStartOfWeek(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setOffDays(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setDirection(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setCurrentDayStyle(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setNonCurrentDayStyle(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setTodayStyle(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setWeekStyle(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setWorkStateStyle(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setOnSelectChange(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
+    native static _CalendarAttribute_setOnRequestData(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
     native static _CalendarPicker_construct(id: KInt, flags: KInt): KPointer
     @ani.unsafe.Direct
     native static _CalendarPickerInterface_setCalendarPickerOptions(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
@@ -3159,12 +3189,6 @@ export class ArkUIGeneratedNativeModule {
     @ani.unsafe.Direct
     native static _BaseContext_getFinalizer(): KPointer
     @ani.unsafe.Direct
-    native static _BaseCustomDialog_construct(thisArray: KSerializerBuffer, thisLength: int32): KPointer
-    @ani.unsafe.Direct
-    native static _BaseCustomDialog_getFinalizer(): KPointer
-    @ani.unsafe.Direct
-    native static _BaseCustomDialog_$_instantiate(thisArray: KSerializerBuffer, thisLength: int32): KPointer
-    @ani.unsafe.Direct
     native static _BaseEvent_construct(): KPointer
     @ani.unsafe.Direct
     native static _BaseEvent_getFinalizer(): KPointer
@@ -3273,6 +3297,14 @@ export class ArkUIGeneratedNativeModule {
     @ani.unsafe.Direct
     native static _BuilderNodeOps_setRootFrameNodeInBuilderNode(ptr: KPointer, node: KPointer): KPointer
     @ani.unsafe.Direct
+    native static _CalendarController_construct(): KPointer
+    @ani.unsafe.Direct
+    native static _CalendarController_getFinalizer(): KPointer
+    @ani.unsafe.Direct
+    native static _CalendarController_backToToday(ptr: KPointer): void
+    @ani.unsafe.Direct
+    native static _CalendarController_goTo(ptr: KPointer, thisArray: KSerializerBuffer, thisLength: int32): void
+    @ani.unsafe.Direct
     native static _CalendarPickerDialog_construct(): KPointer
     @ani.unsafe.Direct
     native static _CalendarPickerDialog_getFinalizer(): KPointer
@@ -6617,21 +6649,21 @@ export class ArkUIGeneratedNativeModule {
     @ani.unsafe.Direct
     native static _TransitionEffect_combine(ptr: KPointer, transitionEffect: KPointer): KPointer
     @ani.unsafe.Direct
-    native static _TransitionEffect_getIDENTITY(ptr: KPointer): KPointer
+    native static _TransitionEffect_getIDENTITY(): KPointer
     @ani.unsafe.Direct
-    native static _TransitionEffect_setIDENTITY(ptr: KPointer, IDENTITY: KPointer): void
+    native static _TransitionEffect_setIDENTITY(IDENTITY: KPointer): void
     @ani.unsafe.Direct
-    native static _TransitionEffect_getOPACITY(ptr: KPointer): KPointer
+    native static _TransitionEffect_getOPACITY(): KPointer
     @ani.unsafe.Direct
-    native static _TransitionEffect_setOPACITY(ptr: KPointer, OPACITY: KPointer): void
+    native static _TransitionEffect_setOPACITY(OPACITY: KPointer): void
     @ani.unsafe.Direct
-    native static _TransitionEffect_getSLIDE(ptr: KPointer): KPointer
+    native static _TransitionEffect_getSLIDE(): KPointer
     @ani.unsafe.Direct
-    native static _TransitionEffect_setSLIDE(ptr: KPointer, SLIDE: KPointer): void
+    native static _TransitionEffect_setSLIDE(SLIDE: KPointer): void
     @ani.unsafe.Direct
-    native static _TransitionEffect_getSLIDE_SWITCH(ptr: KPointer): KPointer
+    native static _TransitionEffect_getSLIDE_SWITCH(): KPointer
     @ani.unsafe.Direct
-    native static _TransitionEffect_setSLIDE_SWITCH(ptr: KPointer, SLIDE_SWITCH: KPointer): void
+    native static _TransitionEffect_setSLIDE_SWITCH(SLIDE_SWITCH: KPointer): void
     @ani.unsafe.Direct
     native static _UICommonEvent_construct(): KPointer
     @ani.unsafe.Direct
diff --git a/arkoala-arkts/arkui/src/generated/arkts/type_check.ets b/arkoala-arkts/arkui/src/generated/arkts/type_check.ets
index 560e4ab220..3b1408b2b8 100644
--- a/arkoala-arkts/arkui/src/generated/arkts/type_check.ets
+++ b/arkoala-arkts/arkui/src/generated/arkts/type_check.ets
@@ -19,7 +19,7 @@
 import { KBoolean, KStringPtr, NativeBuffer, MaterializedBase } from "@koalaui/interop"
 import { int32 } from "@koalaui/common"
 import { AccessibilityHoverType, Alignment, AnimationStatus, AppRotation, ArrowPointPosition, Axis, AxisAction, AxisModel, BarState, BorderStyle, CheckBoxShape, Color, ClickEffectLevel, ColoringStrategy, CopyOptions, CrownAction, CrownSensitivity, DialogButtonStyle, Direction, DividerMode, Edge, EdgeEffect, EllipsisMode, EmbeddedType, FillMode, FlexAlign, FlexDirection, FlexWrap, FocusDrawLevel, FoldStatus, FontStyle, FontWeight, FunctionKey, GradientDirection, HeightBreakpoint, HitTestMode, HorizontalAlign, HoverEffect, IlluminatedType, ImageFit, ImageRepeat, ImageSize, ImageSpanAlignment, InteractionHand, ItemAlign, KeySource, KeyType, LineBreakStrategy, LineCapStyle, LineJoinStyle, MarqueeUpdateStrategy, ModifierKey, MouseAction, MouseButton, NestedScrollMode, ObscuredReasons, OptionWidthMode, PageFlipMode, PixelRoundCalcPolicy, PixelRoundMode, Placement, PlayMode, RelateType, RenderFit, ResponseType, ScrollSource, SharedTransitionEffectType, TextAlign, TextCase, TextContentStyle, TextDecorationStyle, TextDecorationType, TextHeightAdaptivePolicy, TextOverflow, TextSelectableMode, TitleHeight, TouchType, TransitionType, WidthBreakpoint, VerticalAlign, Visibility, Week, WordBreak, XComponentType } from "./../../component/enums"
-import { AccessibilityRoleType, AccessibilitySamePageMode, AdaptiveColor, BlendApplyType, BlendMode, BlurStyle, BlurStyleActivePolicy, TouchEvent, ChainStyle, ContentClipMode, DismissReason, DragBehavior, DraggingSizeChangeEffect, DragPreviewMode, DragResult, EffectEdge, EffectType, FinishCallbackType, SourceTool, GestureModifier, UIGestureEvent, HapticFeedbackMode, HoverModeAreaType, KeyboardAvoidMode, Layoutable, Measurable, GeometryInfo, SizeResult, LayoutPolicy, LayoutSafeAreaEdge, LayoutSafeAreaType, RectResult, CommonConfiguration, TranslateOptions, ScaleOptions, RotateOptions, MenuPolicy, MenuPreviewMode, ModalTransition, NestedScrollOptions, OutlineStyle, PixelMapMock, PopupStateChangeParam, PreDragStatus, ProgressMask, PopupCommonOptions, MenuOptions, RepeatMode, SelectionOptions, SafeAreaEdge, SafeAreaType, ScrollResult, ScrollSizeMode, TextContentControllerBase, ShadowStyle, ShadowType, SheetKeyboardAvoidMode, SheetMode, SheetSize, SheetType, SourceType, CaretOffset, TextContentControllerOptions, ThemeColorMode, TouchTestInfo, TouchTestStrategy, TransitionEdge, TransitionHierarchyStrategy, UICommonEvent, ClickEvent, KeyEvent, HoverCallback, HoverEvent, MouseEvent, SizeChangeCallback, VisibleAreaEventOptions, VisibleAreaChangeCallback, AnimateParam, SheetOptions, AlignRuleOption, BackgroundBrightnessOptions, BackgroundImageOptions, BackgroundOptions, BlurOptions, ChildrenMainSize, ClickEffect, CrownEvent, DateRange, DismissContentCoverAction, DismissPopupAction, DismissSheetAction, DragEvent, ModifierKeyStateGetter, Rectangle, DragInteractionOptions, DragItemInfo, DrawModifier, DropOptions, EdgeEffectOptions, ExpectedFrameRateRange, FocusMovement, ForegroundEffectOptions, GeometryTransitionOptions, InputCounterOptions, InvertOptions, ItemDragInfo, FractionStop, LinearGradientBlurOptions, LinearGradientOptions, LocalizedHorizontalAlignParam, LocalizedVerticalAlignParam, MeasureResult, MotionBlurAnchor, MotionBlurOptions, MotionPathOptions, OverlayOffset, PixelRoundPolicy, PopupButton, PreviewConfiguration, SheetDismiss, SpringBackAction, StateStyles, CustomStyles, SystemAdaptiveOptions, ShadowOptions, TouchObject, TouchResult, BackgroundBlurStyleOptions, BlurStyleOptions, BackgroundEffectOptions, MultiShadowOptions, DragPreviewOptions, FadingEdgeOptions, ForegroundBlurStyleOptions, HistoricalPoint, LightSource, LocalizedAlignRuleOptions, MenuElement, OverlayOptions, PopupMaskType, ReuseOptions, ReuseIdCallback, sharedTransitionOptions, SheetTitleOptions, TerminationInfo, TextDecorationOptions, DividerStyle, PixelStretchEffectOptions, PointLightStyle, RadialGradientOptions, SweepGradientOptions, TipsOptions, BorderImageOption, EventTarget, FocusAxisEvent, BaseEvent, LayoutChild, PickerDialogButtonStyle, PickerTextStyle, PopupMessageOptions, BindOptions, TripleLengthDetents, AccessibilityHoverEvent, AxisEvent, AsymmetricTransitionOption, TransitionEffect, ContentCoverOptions, ContextMenuAnimationOptions, AnimationNumberRange, ContextMenuOptions, BorderRadiusType, CustomPopupOptions, PopupStateChangeCallback, PopupOptions } from "./../../component/common"
+import { AccessibilityRoleType, AccessibilitySamePageMode, AdaptiveColor, BlendApplyType, BlendMode, BlurStyle, BlurStyleActivePolicy, TouchEvent, ChainStyle, ContentClipMode, DismissReason, DragBehavior, DraggingSizeChangeEffect, DragPreviewMode, DragResult, EffectEdge, EffectType, FinishCallbackType, SourceTool, GestureModifier, UIGestureEvent, HapticFeedbackMode, HoverModeAreaType, KeyboardAvoidMode, Layoutable, Measurable, GeometryInfo, SizeResult, LayoutPolicy, LayoutSafeAreaEdge, LayoutSafeAreaType, RectResult, CommonConfiguration, TranslateOptions, ScaleOptions, RotateOptions, MenuPolicy, MenuPreviewMode, ModalTransition, NestedScrollOptions, OutlineStyle, PixelMapMock, PopupStateChangeParam, PreDragStatus, ProgressMask, PopupCommonOptions, MenuOptions, RepeatMode, SelectionOptions, SafeAreaEdge, SafeAreaType, ScrollResult, ScrollSizeMode, TextContentControllerBase, ShadowStyle, ShadowType, SheetKeyboardAvoidMode, SheetMode, SheetSize, SheetType, SourceType, CaretOffset, TextContentControllerOptions, ThemeColorMode, TouchTestInfo, TouchTestStrategy, TransitionEdge, TransitionEffect, AsymmetricTransitionOption, AnimateParam, TransitionHierarchyStrategy, UICommonEvent, ClickEvent, KeyEvent, HoverCallback, HoverEvent, MouseEvent, SizeChangeCallback, VisibleAreaEventOptions, VisibleAreaChangeCallback, SheetOptions, AlignRuleOption, BackgroundBrightnessOptions, BackgroundImageOptions, BackgroundOptions, BlurOptions, ChildrenMainSize, ClickEffect, CrownEvent, DateRange, DismissContentCoverAction, DismissPopupAction, DismissSheetAction, DragEvent, ModifierKeyStateGetter, Rectangle, DragInteractionOptions, DragItemInfo, DrawModifier, DropOptions, EdgeEffectOptions, ExpectedFrameRateRange, FocusMovement, ForegroundEffectOptions, GeometryTransitionOptions, InputCounterOptions, InvertOptions, ItemDragInfo, FractionStop, LinearGradientBlurOptions, LinearGradientOptions, LocalizedHorizontalAlignParam, LocalizedVerticalAlignParam, MeasureResult, MotionBlurAnchor, MotionBlurOptions, MotionPathOptions, OverlayOffset, PixelRoundPolicy, PopupButton, PreviewConfiguration, SheetDismiss, SpringBackAction, StateStyles, CustomStyles, SystemAdaptiveOptions, ShadowOptions, TouchObject, TouchResult, BackgroundBlurStyleOptions, BlurStyleOptions, BackgroundEffectOptions, ContentCoverOptions, BindOptions, ContextMenuAnimationOptions, AnimationNumberRange, MultiShadowOptions, DragPreviewOptions, FadingEdgeOptions, ForegroundBlurStyleOptions, HistoricalPoint, LightSource, LocalizedAlignRuleOptions, MenuElement, OverlayOptions, PopupMaskType, ReuseOptions, ReuseIdCallback, sharedTransitionOptions, SheetTitleOptions, TerminationInfo, TextDecorationOptions, DividerStyle, PixelStretchEffectOptions, PointLightStyle, RadialGradientOptions, SweepGradientOptions, TipsOptions, BorderImageOption, ContextMenuOptions, BorderRadiusType, CustomPopupOptions, PopupStateChangeCallback, EventTarget, FocusAxisEvent, BaseEvent, LayoutChild, PickerDialogButtonStyle, PickerTextStyle, PopupMessageOptions, TripleLengthDetents, AccessibilityHoverEvent, AxisEvent, PopupOptions } from "./../../component/common"
 import { AnimationMode, BarMode, BarPosition, LayoutStyle, TabContentTransitionProxy, TabsAnimationEvent, TabsCacheMode, TabsController, TabContentAnimatedTransition, TabsOptions, BarGridColumnOptions, ScrollableBarModeOptions } from "./../../component/tabs"
 import { ArrowPosition, AvoidanceMode, MenuAlignType, MenuItemConfiguration, SelectOption, MenuOutlineOptions } from "./../../component/select"
 import { AutoCapitalizationMode, KeyboardAppearance, LayoutManager, PositionWithAffinity, MenuType, TextEditControllerEx, PreviewText, StyledStringController, StyledStringChangedListener, TextBaseController, TextRange, TextDataDetectorType, TextDeleteDirection, TextMenuOptions, TextMenuItemId, TextMenuShowMode, TextMenuItem, DeleteValue, EditMenuOptions, OnCreateMenuCallback, OnMenuItemClickCallback, FontSettingOptions, InsertValue, StyledStringChangeValue, OnDidChangeCallback, DecorationStyleResult, TextChangeOptions, CaretStyle, EditableTextChangeValue, TextDataDetectorConfig } from "./../../component/textCommon"
@@ -27,9 +27,6 @@ import { BadgePosition, BadgeStyle, BadgeParamWithNumber, BadgeParam, BadgeParam
 import { BarrierDirection, LocalizedBarrierDirection, BarrierStyle, GuideLinePosition, GuideLineStyle } from "./../../component/relativeContainer"
 import { BarStyle, LaunchMode, NavBarPosition, NavigationMode, NavigationOperation, NavigationTitleMode, NavPathInfo, NavPathStack, NavigationOptions, PopInfo, NavigationInterception, ToolbarItemStatus, NavContentInfo, NavigationAnimatedTransition, NavigationTransitionProxy, InterceptionShowCallback, NavBar, InterceptionModeCallback, NavigationCommonTitle, NavigationMenuItem, UpdateTransitionCallback, ToolbarItem, MoreButtonOptions, NavigationCustomTitle, NavigationTitleOptions, NavigationMenuOptions, NavigationToolbarOptions } from "./../../component/navigation"
 import { BaseContext } from "./../application.BaseContext"
-import { BaseCustomComponent, ContentModifier, CustomComponentV2 } from "./../../handwritten"
-import { ExtendableComponent, LifeCycle } from "./../../component/extendableComponent"
-import { LayoutCallback, PageLifeCycle } from "./../../component/customComponent"
 import { BaseShape, BuilderNodeOps, BuilderNodeOptions, CommonShape, Offset_componentutils, PerfMonitorActionType, PerfMonitorSourceType, RotateResult, ScaleResult, Scene, TranslateResult, WorkerEventListener, Event, DoubleAnimationParam, Callback_Extender_OnProgress, Callback_Extender_OnFinish, ErrorEvent, FontInfo, MessageEvents, PostMessageOptions, SnapshotOptions, WorkerOptions, ComponentInfo, Matrix4Result, FontOptions, MeasureOptions, RestrictedWorker, RestrictedWorker_onexit_Callback, RestrictedWorker_onerror_Callback, RestrictedWorker_onmessage_Callback } from "./../../component/idlize"
 import { Length, SizeOptions, Position, ResourceColor, ColorFilter, ConstraintSizeOptions, ResourceStr, VoidCallback, AccessibilityOptions, Bias, ChainWeightOptions, DirectionalEdgesT, EdgeOutlineStyles, EdgeStyles, VP, DividerStyleOptions, EdgeColors, LengthConstrain, Dimension, LocalizedBorderRadiuses, LocalizedEdgeColors, LocalizedEdges, LocalizedEdgeWidths, LocalizedPadding, LocalizedPosition, Offset, BorderRadiuses, EdgeOutlineWidths, Edges, EdgeWidths, Font, PX, LPX, MarkStyle, OutlineRadiuses, Padding, Area, BorderOptions, OutlineOptions } from "./../../component/units"
 import { Resource } from "./../resource"
@@ -37,6 +34,7 @@ import { BlurOnKeyboardHideMode, CacheMode, ClientAuthenticationHandler, Console
 import { BreakpointsReference, GridRowDirection, BreakPoints, GridRowColumnOption, GridRowSizeOption, GutterOption, GridRowOptions } from "./../../component/gridRow"
 import { ButtonRole, ButtonStyleMode, ButtonType, ControlSize, ButtonConfiguration, ButtonTriggerClickCallback, ButtonOptions, ButtonLabelStyle } from "./../../component/button"
 import { CalendarAlign, CalendarPickerDialog, CalendarDialogOptions, CalendarOptions } from "./../../component/calendarPicker"
+import { CalendarController, CalendarSelectedDate, CalendarDay, CalendarRequestedData, MonthData, CalendarRequestedMonths, CurrentDayStyle, NonCurrentDayStyle, TodayStyle, WeekStyle, WorkStateStyle } from "./../../component/calendar"
 import { CancelButtonStyle, SearchController, SearchType, CancelButtonSymbolOptions, SearchOptions, IconOptions, SearchButtonOptions, CancelButtonOptions } from "./../../component/search"
 import { CanvasGradient, CanvasPath, CanvasPattern, OffscreenCanvas, ImageBitmap, RenderingContextSettings, OffscreenCanvasRenderingContext2D, Path2D, TextMetrics, DrawingRenderingContext, ImageData, CanvasRenderer, ImageSmoothingQuality, CanvasLineCap, CanvasLineJoin, CanvasDirection, CanvasTextAlign, CanvasTextBaseline, CanvasFillRule, CanvasRenderingContext2D } from "./../../component/canvas"
 import { Matrix2D } from "./../../component/matrix2d"
@@ -47,6 +45,7 @@ import { ColorContent, DynamicRangeMode, ImageContent, ImageInterpolation, Image
 import { ColorMetrics, CornerRadius, DrawContext, Size, LengthMetricsUnit, LengthUnit, ShapeClip, RoundRect, Circle, CommandPath, ShapeMask, Vector2, Vector3, LengthMetrics, Frame } from "./../arkui.Graphics"
 import { ColorMode, LayoutDirection } from "./../../component/stateManagement"
 import { ComponentContent } from "./../arkui.ComponentContent"
+import { ContentModifier } from "./../../handwritten"
 import { ContentType, EnterKeyType, InputType, SubmitEvent, TextInputController, TextInputStyle, PasswordIcon, TextInputOptions, UnderlineColor } from "./../../component/textInput"
 import { Context } from "./../application.Context"
 import { webview } from "./../ohos.web.webview"
@@ -65,6 +64,7 @@ import { common2D } from "./../ohos.graphics.common2D"
 import { EffectDirection, EffectFillStyle, EffectScope, SymbolEffect, SymbolEffectStrategy, SymbolRenderingStrategy, AppearSymbolEffect, BounceSymbolEffect, DisappearSymbolEffect, HierarchicalSymbolEffect, ReplaceSymbolEffect, ScaleSymbolEffect } from "./../../component/symbolglyph"
 import { EllipseOptions } from "./../../component/ellipse"
 import { EventTargetInfo, Gesture, GestureControl, GestureType, GestureMode, GestureJudgeResult, GestureMask, GesturePriority, GestureRecognizer, GestureRecognizerState, LongPressGestureHandlerOptions, GestureEvent, LongPressRecognizer, PanDirection, PanGestureOptions, PanGestureHandlerOptions, PanRecognizer, PinchGestureHandlerOptions, PinchRecognizer, RotationGesture, RotationGestureHandlerOptions, RotationRecognizer, ScrollableTargetInfo, SwipeDirection, SwipeGesture, SwipeGestureHandlerOptions, SwipeRecognizer, TapGestureParameters, TapRecognizer, GestureHandler, FingerInfo, GestureInfo, BaseHandlerOptions, LongPressGestureEvent, BaseGestureEvent, PanGestureEvent, PinchGestureEvent, RotationGestureEvent, SwipeGestureEvent, TapGestureEvent } from "./../../component/gesture"
+import { ExtendableComponent, LifeCycle } from "./../../component/extendableComponent"
 import { UIContext, PromptAction, TargetInfo, TextMenuController } from "./../ohos.arkui.UIContext"
 import { FocusPriority, KeyProcessingMode, FocusBoxStyle } from "./../../component/focus"
 import { FormDimension, FormRenderingMode, FormShape, FormSize, ErrorInformation, FormCallbackInfo, FormInfo } from "./../../component/formComponent"
@@ -81,6 +81,7 @@ import { IndexerAlign, AlphabetIndexerOptions } from "./../../component/alphabet
 import { IndicatorComponentController } from "./../../component/indicatorcomponent"
 import { IntentionCode } from "./../ohos.multimodalInput.intentionCode"
 import { ItemState } from "./../../component/stepperItem"
+import { LayoutCallback, PageLifeCycle } from "./../../component/customComponent"
 import { LayoutMode, SelectedMode, TabBarSymbol, TabBarIconStyle, TabBarOptions, BoardStyle, SubTabBarIndicatorStyle, TabBarLabelStyle, BottomTabBarStyle, SubTabBarStyle } from "./../../component/tabContent"
 import { LinearIndicatorController, LinearIndicatorStartOptions, LinearIndicatorStyle } from "./../../component/linearindicator"
 import { LineOptions, ShapePoint } from "./../../component/line"
@@ -312,9 +313,6 @@ export class TypeChecker {
     static isBaseContext(value: Object | string | number | undefined): boolean {
         return value instanceof BaseContext
     }
-    static isBaseCustomComponent(value: Object | string | number | undefined): boolean {
-        return value instanceof BaseCustomComponent
-    }
     static isBaseEvent(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean, arg7: boolean, arg8: boolean, arg9: boolean, arg10: boolean, arg11: boolean, arg12: boolean): boolean {
         return value instanceof BaseEvent
     }
@@ -417,6 +415,12 @@ export class TypeChecker {
     static isCalendarAlign(value: Object | string | number | undefined): boolean {
         return value instanceof CalendarAlign
     }
+    static isCalendarController(value: Object | string | number | undefined): boolean {
+        return value instanceof CalendarController
+    }
+    static isCalendarDay(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean, arg7: boolean, arg8: boolean, arg9: boolean, arg10: boolean): boolean {
+        return value instanceof CalendarDay
+    }
     static isCalendarDialogOptions(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean, arg7: boolean, arg8: boolean, arg9: boolean, arg10: boolean, arg11: boolean, arg12: boolean, arg13: boolean, arg14: boolean, arg15: boolean, arg16: boolean): boolean {
         return value instanceof CalendarDialogOptions
     }
@@ -426,6 +430,15 @@ export class TypeChecker {
     static isCalendarPickerDialog(value: Object | string | number | undefined): boolean {
         return value instanceof CalendarPickerDialog
     }
+    static isCalendarRequestedData(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean): boolean {
+        return value instanceof CalendarRequestedData
+    }
+    static isCalendarRequestedMonths(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean): boolean {
+        return value instanceof CalendarRequestedMonths
+    }
+    static isCalendarSelectedDate(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
+        return value instanceof CalendarSelectedDate
+    }
     static isCancelButtonOptions(value: Object | string | number | undefined, arg0: boolean, arg1: boolean): boolean {
         return value instanceof CancelButtonOptions
     }
@@ -648,15 +661,15 @@ export class TypeChecker {
     static isCrownSensitivity(value: Object | string | number | undefined): boolean {
         return value instanceof CrownSensitivity
     }
+    static isCurrentDayStyle(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean, arg7: boolean, arg8: boolean, arg9: boolean, arg10: boolean, arg11: boolean, arg12: boolean, arg13: boolean, arg14: boolean, arg15: boolean, arg16: boolean, arg17: boolean, arg18: boolean, arg19: boolean, arg20: boolean, arg21: boolean, arg22: boolean): boolean {
+        return value instanceof CurrentDayStyle
+    }
     static iscurves_Curve(value: Object | string | number | undefined): boolean {
         return value instanceof curves.Curve
     }
     static iscurves_ICurve(value: Object | string | number | undefined): boolean {
         return value instanceof curves.ICurve
     }
-    static isCustomComponentV2(value: Object | string | number | undefined): boolean {
-        return value instanceof CustomComponentV2
-    }
     static isCustomDialogController(value: Object | string | number | undefined): boolean {
         return value instanceof CustomDialogController
     }
@@ -1758,6 +1771,9 @@ export class TypeChecker {
     static isModifierKey(value: Object | string | number | undefined): boolean {
         return value instanceof ModifierKey
     }
+    static isMonthData(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
+        return value instanceof MonthData
+    }
     static isMoreButtonOptions(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
         return value instanceof MoreButtonOptions
     }
@@ -1896,6 +1912,9 @@ export class TypeChecker {
     static isNodeController(value: Object | string | number | undefined): boolean {
         return value instanceof NodeController
     }
+    static isNonCurrentDayStyle(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean): boolean {
+        return value instanceof NonCurrentDayStyle
+    }
     static isObscuredReasons(value: Object | string | number | undefined): boolean {
         return value instanceof ObscuredReasons
     }
@@ -3258,6 +3277,9 @@ export class TypeChecker {
     static isTitleHeight(value: Object | string | number | undefined): boolean {
         return value instanceof TitleHeight
     }
+    static isTodayStyle(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean): boolean {
+        return value instanceof TodayStyle
+    }
     static isToggleConfiguration(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
         return value instanceof ToggleConfiguration
     }
@@ -3294,7 +3316,7 @@ export class TypeChecker {
     static isTransitionEdge(value: Object | string | number | undefined): boolean {
         return value instanceof TransitionEdge
     }
-    static isTransitionEffect(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean): boolean {
+    static isTransitionEffect(value: Object | string | number | undefined): boolean {
         return value instanceof TransitionEffect
     }
     static isTransitionHierarchyStrategy(value: Object | string | number | undefined): boolean {
@@ -3459,6 +3481,9 @@ export class TypeChecker {
     static isWeek(value: Object | string | number | undefined): boolean {
         return value instanceof Week
     }
+    static isWeekStyle(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean): boolean {
+        return value instanceof WeekStyle
+    }
     static isWidthBreakpoint(value: Object | string | number | undefined): boolean {
         return value instanceof WidthBreakpoint
     }
@@ -3483,6 +3508,9 @@ export class TypeChecker {
     static isWorkerOptions(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
         return value instanceof WorkerOptions
     }
+    static isWorkStateStyle(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean, arg3: boolean, arg4: boolean, arg5: boolean, arg6: boolean): boolean {
+        return value instanceof WorkStateStyle
+    }
     static isXComponentController(value: Object | string | number | undefined, arg0: boolean, arg1: boolean, arg2: boolean): boolean {
         return value instanceof XComponentController
     }
@@ -5697,6 +5725,9 @@ export class TypeChecker {
     static isArray_Tuple_ResourceColor_Number(value: Object | string | number | undefined): boolean {
         return value instanceof Array
     }
+    static isArray_CalendarDay(value: Object | string | number | undefined): boolean {
+        return value instanceof Array
+    }
     static isArray_Buffer(value: Object | string | number | undefined): boolean {
         return value instanceof Array
     }
diff --git a/arkoala-arkts/arkui/src/generated/index.ets b/arkoala-arkts/arkui/src/generated/index.ets
index 9ce785cc88..dc4f2ac46d 100644
--- a/arkoala-arkts/arkui/src/generated/index.ets
+++ b/arkoala-arkts/arkui/src/generated/index.ets
@@ -24,6 +24,7 @@ export * from "./../component/badge"
 export * from "./../component/blank"
 export * from "./../component/builder"
 export * from "./../component/button"
+export * from "./../component/calendar"
 export * from "./../component/calendarPicker"
 export * from "./../component/canvas"
 export * from "./../component/checkbox"
diff --git a/arkoala-arkts/arkui/src/generated/ohos.multimedia.image.ets b/arkoala-arkts/arkui/src/generated/ohos.multimedia.image.ets
index c66bd9135a..f52ef20553 100644
--- a/arkoala-arkts/arkui/src/generated/ohos.multimedia.image.ets
+++ b/arkoala-arkts/arkui/src/generated/ohos.multimedia.image.ets
@@ -36,8 +36,8 @@ export class image_PixelMap_serializer {
 }
 export namespace image {
     export interface PixelMap {
-        isEditable: boolean
-        isStrideAlignment: boolean
+        readonly isEditable: boolean
+        readonly isStrideAlignment: boolean
         readPixelsToBufferSync(dst: NativeBuffer): void
         writeBufferToPixels(src: NativeBuffer): void
     }
@@ -46,8 +46,8 @@ export namespace image {
         public getPeer(): Finalizable | undefined {
             return this.peer
         }
-        isEditable: boolean
-        isStrideAlignment: boolean
+        readonly isEditable: boolean
+        readonly isStrideAlignment: boolean
         constructor(peerPtr: KPointer) {
             this.peer = new Finalizable(peerPtr, PixelMapInternal.getFinalizer())
             this.isEditable = this.getIsEditable()
diff --git a/arkoala-arkts/arkui/src/generated/peers/CallbackDeserializeCall.ets b/arkoala-arkts/arkui/src/generated/peers/CallbackDeserializeCall.ets
index 2a48013f57..1f5ab1b340 100644
--- a/arkoala-arkts/arkui/src/generated/peers/CallbackDeserializeCall.ets
+++ b/arkoala-arkts/arkui/src/generated/peers/CallbackDeserializeCall.ets
@@ -16,11 +16,12 @@
 
 // WARNING! THIS FILE IS AUTO-GENERATED, DO NOT MAKE CHANGES, THEY WILL BE LOST ON NEXT GENERATION!
 
-import { AccessibilityHoverEvent_serializer, TouchTestInfo_serializer, TouchResult_serializer, AxisEvent_serializer, HoverEvent_serializer, ClickEvent_serializer, CrownEvent_serializer, DismissContentCoverAction_serializer, DismissPopupAction_serializer, DismissSheetAction_serializer, DragEvent_serializer, FocusAxisEvent_serializer, ItemDragInfo_serializer, KeyEvent_serializer, MouseEvent_serializer, GeometryInfo_serializer, Measurable_serializer, SizeResult_serializer, Layoutable_serializer, ScrollResult_serializer, SheetDismiss_serializer, SpringBackAction_serializer, TerminationInfo_serializer, TouchEvent_serializer, DragItemInfo_serializer, PopupStateChangeParam_serializer, AccessibilityCallback, AccessibilityHoverEvent, AccessibilityFocusCallback, TouchTestInfo, TouchResult, AxisEvent, HoverEvent, ClickEvent, CrownEvent, DismissContentCoverAction, DismissPopupAction, DismissSheetAction, DragEvent, FocusAxisEvent, ItemDragInfo, KeyEvent, MouseEvent, GeometryInfo, Measurable, SizeResult, Layoutable, ScrollResult, PreDragStatus, SheetDismiss, SheetType, SpringBackAction, TerminationInfo, TouchEvent, DragItemInfo, GestureRecognizerJudgeBeginCallback, HoverCallback, ModifierKeyStateGetter, OnDragEventCallback, OnItemDragStartCallback, OnMoveHandler, OnScrollCallback, OnWillScrollCallback, PopupStateChangeCallback, PopupStateChangeParam, ReuseIdCallback, ShouldBuiltInRecognizerParallelWithCallback, SizeChangeCallback, TransitionFinishCallback, VisibleAreaChangeCallback } from "./../../component/common"
+import { AccessibilityHoverEvent_serializer, TouchTestInfo_serializer, TouchResult_serializer, AxisEvent_serializer, HoverEvent_serializer, ClickEvent_serializer, CrownEvent_serializer, DismissContentCoverAction_serializer, DismissPopupAction_serializer, DismissSheetAction_serializer, DragEvent_serializer, FocusAxisEvent_serializer, ItemDragInfo_serializer, KeyEvent_serializer, MouseEvent_serializer, GeometryInfo_serializer, Measurable_serializer, SizeResult_serializer, Layoutable_serializer, ScrollResult_serializer, SheetDismiss_serializer, SpringBackAction_serializer, TerminationInfo_serializer, TouchEvent_serializer, DragItemInfo_serializer, PopupStateChangeParam_serializer, AccessibilityCallback, AccessibilityHoverEvent, AccessibilityFocusCallback, TouchTestInfo, TouchResult, AxisEvent, HoverEvent, ClickEvent, CrownEvent, DismissContentCoverAction, DismissPopupAction, DismissSheetAction, DragEvent, FocusAxisEvent, ItemDragInfo, KeyEvent, MouseEvent, GeometryInfo, Measurable, SizeResult, Layoutable, ScrollResult, PreDragStatus, SheetDismiss, SheetType, SpringBackAction, TerminationInfo, TouchEvent, DragItemInfo, CustomStyles, GestureRecognizerJudgeBeginCallback, HoverCallback, ModifierKeyStateGetter, OnDragEventCallback, OnItemDragStartCallback, OnMoveHandler, OnScrollCallback, OnWillScrollCallback, PopupStateChangeCallback, PopupStateChangeParam, ReuseIdCallback, ShouldBuiltInRecognizerParallelWithCallback, SizeChangeCallback, TransitionFinishCallback, VisibleAreaChangeCallback } from "./../../component/common"
 import { image_PixelMap_serializer, image } from "./../ohos.multimedia.image"
 import { ButtonConfiguration_serializer, ButtonConfiguration, ButtonTriggerClickCallback } from "./../../component/button"
 import { Area_serializer, ConstraintSizeOptions_serializer, SizeOptions_serializer, Area, ConstraintSizeOptions, ResourceStr, SizeOptions, VoidCallback } from "./../../component/units"
 import { TextMenuItem_serializer, DeleteValue_serializer, EditableTextChangeValue_serializer, InsertValue_serializer, StyledStringChangeValue_serializer, TextRange_serializer, PreviewText_serializer, TextChangeOptions_serializer, TextMenuItem, DeleteValue, EditableTextChangeValue, InsertValue, StyledStringChangeValue, TextRange, EditableTextOnChangeCallback, PreviewText, TextChangeOptions, OnCreateMenuCallback, OnDidChangeCallback, OnMenuItemClickCallback } from "./../../component/textCommon"
+import { CalendarRequestedData_serializer, CalendarSelectedDate_serializer, CalendarRequestedData, CalendarSelectedDate } from "./../../component/calendar"
 import { CompatibleComponentInfo_serializer, CompatibleComponentInfo, CompatibleInitCallback, CompatibleUpdateCallback } from "./../../component/interop"
 import { ComputedBarAttribute_serializer, ComputedBarAttribute } from "./../../component/grid"
 import { CopyEvent_serializer, CutEvent_serializer, RichEditorChangeValue_serializer, RichEditorDeleteValue_serializer, RichEditorInsertValue_serializer, RichEditorRange_serializer, RichEditorSelection_serializer, RichEditorTextSpanResult_serializer, PasteEvent_serializer, CopyEvent, CutEvent, RichEditorChangeValue, RichEditorDeleteValue, RichEditorInsertValue, RichEditorRange, RichEditorSelection, RichEditorTextSpanResult, PasteEvent, MenuCallback, MenuOnAppearCallback, OnHoverCallback, PasteEventCallback, SubmitCallback } from "./../../component/richEditor"
@@ -237,6 +238,18 @@ export function deserializeAndCallCallback_Buffer_Void(thisDeserializer: Deseria
     let value : NativeBuffer = (thisDeserializer.readBuffer() as NativeBuffer)
     _call(value)
 }
+export function deserializeAndCallCallback_CalendarRequestedData_Void(thisDeserializer: DeserializerBase): void {
+    const _resourceId : int32 = thisDeserializer.readInt32()
+    const _call  = (ResourceHolder.instance().get(_resourceId) as ((event: CalendarRequestedData) => void))
+    let event : CalendarRequestedData = CalendarRequestedData_serializer.read(thisDeserializer)
+    _call(event)
+}
+export function deserializeAndCallCallback_CalendarSelectedDate_Void(thisDeserializer: DeserializerBase): void {
+    const _resourceId : int32 = thisDeserializer.readInt32()
+    const _call  = (ResourceHolder.instance().get(_resourceId) as ((event: CalendarSelectedDate) => void))
+    let event : CalendarSelectedDate = CalendarSelectedDate_serializer.read(thisDeserializer)
+    _call(event)
+}
 export function deserializeAndCallCallback_ClickEvent_LocationButtonOnClickResult_Void(thisDeserializer: DeserializerBase): void {
     const _resourceId : int32 = thisDeserializer.readInt32()
     const _call  = (ResourceHolder.instance().get(_resourceId) as ((event: ClickEvent,result: LocationButtonOnClickResult) => void))
@@ -2141,6 +2154,12 @@ export function deserializeAndCallCustomNodeBuilder(thisDeserializer: Deserializ
     const _callResult  = _call(parentNode)
     _continuation(_callResult)
 }
+export function deserializeAndCallCustomStyles(thisDeserializer: DeserializerBase): void {
+    const _resourceId : int32 = thisDeserializer.readInt32()
+    const _call  = (ResourceHolder.instance().get(_resourceId) as CustomStyles)
+    let instance : string = (thisDeserializer.readString() as string)
+    _call(instance)
+}
 export function deserializeAndCallDataPanelModifierBuilder(thisDeserializer: DeserializerBase): void {
     const _resourceId : int32 = thisDeserializer.readInt32()
     const _call  = (ResourceHolder.instance().get(_resourceId) as ((parentNode: KPointer,config: DataPanelConfiguration) => KPointer))
@@ -3555,6 +3574,8 @@ export function deserializeAndCallCallback(thisDeserializer: DeserializerBase):
         case CallbackKind.Kind_Callback_Boolean_HoverEvent_Void: return deserializeAndCallCallback_Boolean_HoverEvent_Void(thisDeserializer);
         case CallbackKind.Kind_Callback_Boolean_Void: return deserializeAndCallCallback_Boolean_Void(thisDeserializer);
         case CallbackKind.Kind_Callback_Buffer_Void: return deserializeAndCallCallback_Buffer_Void(thisDeserializer);
+        case CallbackKind.Kind_Callback_CalendarRequestedData_Void: return deserializeAndCallCallback_CalendarRequestedData_Void(thisDeserializer);
+        case CallbackKind.Kind_Callback_CalendarSelectedDate_Void: return deserializeAndCallCallback_CalendarSelectedDate_Void(thisDeserializer);
         case CallbackKind.Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_LocationButtonOnClickResult_Void(thisDeserializer);
         case CallbackKind.Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_PasteButtonOnClickResult_Void(thisDeserializer);
         case CallbackKind.Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_SaveButtonOnClickResult_Void(thisDeserializer);
@@ -3730,6 +3751,7 @@ export function deserializeAndCallCallback(thisDeserializer: DeserializerBase):
         case CallbackKind.Kind_ContentWillScrollCallback: return deserializeAndCallContentWillScrollCallback(thisDeserializer);
         case CallbackKind.Kind_Context_getGroupDir_Callback: return deserializeAndCallContext_getGroupDir_Callback(thisDeserializer);
         case CallbackKind.Kind_CustomNodeBuilder: return deserializeAndCallCustomNodeBuilder(thisDeserializer);
+        case CallbackKind.Kind_CustomStyles: return deserializeAndCallCustomStyles(thisDeserializer);
         case CallbackKind.Kind_DataPanelModifierBuilder: return deserializeAndCallDataPanelModifierBuilder(thisDeserializer);
         case CallbackKind.Kind_EditableTextOnChangeCallback: return deserializeAndCallEditableTextOnChangeCallback(thisDeserializer);
         case CallbackKind.Kind_ErrorCallback: return deserializeAndCallErrorCallback(thisDeserializer);
diff --git a/arkoala-arkts/arkui/src/generated/peers/CallbackKind.ets b/arkoala-arkts/arkui/src/generated/peers/CallbackKind.ets
index 9eec45f973..7934819a3e 100644
--- a/arkoala-arkts/arkui/src/generated/peers/CallbackKind.ets
+++ b/arkoala-arkts/arkui/src/generated/peers/CallbackKind.ets
@@ -15,6 +15,8 @@ export enum CallbackKind {
     Kind_Callback_Boolean_HoverEvent_Void = -916602978,
     Kind_Callback_Boolean_Void = 313269291,
     Kind_Callback_Buffer_Void = 908731311,
+    Kind_Callback_CalendarRequestedData_Void = 1074619005,
+    Kind_Callback_CalendarSelectedDate_Void = -289198976,
     Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void = -1189087745,
     Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void = 659292561,
     Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void = 846787331,
@@ -190,6 +192,7 @@ export enum CallbackKind {
     Kind_ContentWillScrollCallback = -2146044511,
     Kind_Context_getGroupDir_Callback = 260483890,
     Kind_CustomNodeBuilder = 1766817632,
+    Kind_CustomStyles = -1565709723,
     Kind_DataPanelModifierBuilder = -238036926,
     Kind_EditableTextOnChangeCallback = -1729563209,
     Kind_ErrorCallback = -1936519453,
diff --git a/arkoala-arkts/arkui/src/generated/ts/type_check.ets b/arkoala-arkts/arkui/src/generated/ts/type_check.ets
new file mode 100644
index 0000000000..40af66c81c
--- /dev/null
+++ b/arkoala-arkts/arkui/src/generated/ts/type_check.ets
@@ -0,0 +1,19836 @@
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+// WARNING! THIS FILE IS AUTO-GENERATED, DO NOT MAKE CHANGES, THEY WILL BE LOST ON NEXT GENERATION!
+
+import { KBoolean, KStringPtr, NativeBuffer, MaterializedBase } from "@koalaui/interop"
+import { int32 } from "@koalaui/common"
+import { AccessibilityHoverType, Alignment, AnimationStatus, AppRotation, ArrowPointPosition, Axis, AxisAction, AxisModel, BarState, BorderStyle, CheckBoxShape, Color, ClickEffectLevel, ColoringStrategy, CopyOptions, CrownAction, CrownSensitivity, DialogButtonStyle, Direction, DividerMode, Edge, EdgeEffect, EllipsisMode, EmbeddedType, FillMode, FlexAlign, FlexDirection, FlexWrap, FocusDrawLevel, FoldStatus, FontStyle, FontWeight, FunctionKey, GradientDirection, HeightBreakpoint, HitTestMode, HorizontalAlign, HoverEffect, IlluminatedType, ImageFit, ImageRepeat, ImageSize, ImageSpanAlignment, InteractionHand, ItemAlign, KeySource, KeyType, LineBreakStrategy, LineCapStyle, LineJoinStyle, MarqueeUpdateStrategy, ModifierKey, MouseAction, MouseButton, NestedScrollMode, ObscuredReasons, OptionWidthMode, PageFlipMode, PixelRoundCalcPolicy, PixelRoundMode, Placement, PlayMode, RelateType, RenderFit, ResponseType, ScrollSource, SharedTransitionEffectType, TextAlign, TextCase, TextContentStyle, TextDecorationStyle, TextDecorationType, TextHeightAdaptivePolicy, TextOverflow, TextSelectableMode, TitleHeight, TouchType, TransitionType, WidthBreakpoint, VerticalAlign, Visibility, Week, WordBreak, XComponentType } from "./../../component/enums"
+import { AccessibilityRoleType, AccessibilitySamePageMode, AdaptiveColor, BlendApplyType, BlendMode, BlurStyle, BlurStyleActivePolicy, TouchEvent, ChainStyle, ContentClipMode, DismissReason, DragBehavior, DraggingSizeChangeEffect, DragPreviewMode, DragResult, EffectEdge, EffectType, FinishCallbackType, SourceTool, GestureModifier, UIGestureEvent, HapticFeedbackMode, HoverModeAreaType, KeyboardAvoidMode, Layoutable, Measurable, GeometryInfo, SizeResult, LayoutPolicy, LayoutSafeAreaEdge, LayoutSafeAreaType, RectResult, CommonConfiguration, TranslateOptions, ScaleOptions, RotateOptions, MenuPolicy, MenuPreviewMode, ModalTransition, NestedScrollOptions, OutlineStyle, PixelMapMock, PopupStateChangeParam, PreDragStatus, ProgressMask, PopupCommonOptions, MenuOptions, RepeatMode, SelectionOptions, SafeAreaEdge, SafeAreaType, ScrollResult, ScrollSizeMode, TextContentControllerBase, ShadowStyle, ShadowType, SheetKeyboardAvoidMode, SheetMode, SheetSize, SheetType, SourceType, CaretOffset, TextContentControllerOptions, ThemeColorMode, TouchTestInfo, TouchTestStrategy, TransitionEdge, TransitionEffect, AsymmetricTransitionOption, AnimateParam, TransitionHierarchyStrategy, UICommonEvent, ClickEvent, KeyEvent, HoverCallback, HoverEvent, MouseEvent, SizeChangeCallback, VisibleAreaEventOptions, VisibleAreaChangeCallback, SheetOptions, AlignRuleOption, BackgroundBrightnessOptions, BackgroundImageOptions, BackgroundOptions, BlurOptions, ChildrenMainSize, ClickEffect, CrownEvent, DateRange, DismissContentCoverAction, DismissPopupAction, DismissSheetAction, DragEvent, ModifierKeyStateGetter, Rectangle, DragInteractionOptions, DragItemInfo, DrawModifier, DropOptions, EdgeEffectOptions, ExpectedFrameRateRange, FocusMovement, ForegroundEffectOptions, GeometryTransitionOptions, InputCounterOptions, InvertOptions, ItemDragInfo, FractionStop, LinearGradientBlurOptions, LinearGradientOptions, LocalizedHorizontalAlignParam, LocalizedVerticalAlignParam, MeasureResult, MotionBlurAnchor, MotionBlurOptions, MotionPathOptions, OverlayOffset, PixelRoundPolicy, PopupButton, PreviewConfiguration, SheetDismiss, SpringBackAction, StateStyles, CustomStyles, SystemAdaptiveOptions, ShadowOptions, TouchObject, TouchResult, BackgroundBlurStyleOptions, BlurStyleOptions, BackgroundEffectOptions, ContentCoverOptions, BindOptions, ContextMenuAnimationOptions, AnimationNumberRange, MultiShadowOptions, DragPreviewOptions, FadingEdgeOptions, ForegroundBlurStyleOptions, HistoricalPoint, LightSource, LocalizedAlignRuleOptions, MenuElement, OverlayOptions, PopupMaskType, ReuseOptions, ReuseIdCallback, sharedTransitionOptions, SheetTitleOptions, TerminationInfo, TextDecorationOptions, DividerStyle, PixelStretchEffectOptions, PointLightStyle, RadialGradientOptions, SweepGradientOptions, TipsOptions, BorderImageOption, ContextMenuOptions, BorderRadiusType, CustomPopupOptions, PopupStateChangeCallback, EventTarget, FocusAxisEvent, BaseEvent, LayoutChild, PickerDialogButtonStyle, PickerTextStyle, PopupMessageOptions, TripleLengthDetents, AccessibilityHoverEvent, AxisEvent, PopupOptions } from "./../../component/common"
+import { AnimationMode, BarMode, BarPosition, LayoutStyle, TabContentTransitionProxy, TabsAnimationEvent, TabsCacheMode, TabsController, TabContentAnimatedTransition, TabsOptions, BarGridColumnOptions, ScrollableBarModeOptions } from "./../../component/tabs"
+import { ArrowPosition, AvoidanceMode, MenuAlignType, MenuItemConfiguration, SelectOption, MenuOutlineOptions } from "./../../component/select"
+import { AutoCapitalizationMode, KeyboardAppearance, LayoutManager, PositionWithAffinity, MenuType, TextEditControllerEx, PreviewText, StyledStringController, StyledStringChangedListener, TextBaseController, TextRange, TextDataDetectorType, TextDeleteDirection, TextMenuOptions, TextMenuItemId, TextMenuShowMode, TextMenuItem, DeleteValue, EditMenuOptions, OnCreateMenuCallback, OnMenuItemClickCallback, FontSettingOptions, InsertValue, StyledStringChangeValue, OnDidChangeCallback, DecorationStyleResult, TextChangeOptions, CaretStyle, EditableTextChangeValue, TextDataDetectorConfig } from "./../../component/textCommon"
+import { BadgePosition, BadgeStyle, BadgeParamWithNumber, BadgeParam, BadgeParamWithString } from "./../../component/badge"
+import { BarrierDirection, LocalizedBarrierDirection, BarrierStyle, GuideLinePosition, GuideLineStyle } from "./../../component/relativeContainer"
+import { BarStyle, LaunchMode, NavBarPosition, NavigationMode, NavigationOperation, NavigationTitleMode, NavPathInfo, NavPathStack, NavigationOptions, PopInfo, NavigationInterception, ToolbarItemStatus, NavContentInfo, NavigationAnimatedTransition, NavigationTransitionProxy, InterceptionShowCallback, NavBar, InterceptionModeCallback, NavigationCommonTitle, NavigationMenuItem, UpdateTransitionCallback, ToolbarItem, MoreButtonOptions, NavigationCustomTitle, NavigationTitleOptions, NavigationMenuOptions, NavigationToolbarOptions } from "./../../component/navigation"
+import { BaseContext } from "./../application.BaseContext"
+import { BaseShape, BuilderNodeOps, BuilderNodeOptions, CommonShape, Offset_componentutils, PerfMonitorActionType, PerfMonitorSourceType, RotateResult, ScaleResult, Scene, TranslateResult, WorkerEventListener, Event, DoubleAnimationParam, Callback_Extender_OnProgress, Callback_Extender_OnFinish, ErrorEvent, FontInfo, MessageEvents, PostMessageOptions, SnapshotOptions, WorkerOptions, ComponentInfo, Matrix4Result, FontOptions, MeasureOptions, RestrictedWorker, RestrictedWorker_onexit_Callback, RestrictedWorker_onerror_Callback, RestrictedWorker_onmessage_Callback } from "./../../component/idlize"
+import { Length, SizeOptions, Position, ResourceColor, ColorFilter, ConstraintSizeOptions, ResourceStr, VoidCallback, AccessibilityOptions, Bias, ChainWeightOptions, DirectionalEdgesT, EdgeOutlineStyles, EdgeStyles, VP, DividerStyleOptions, EdgeColors, LengthConstrain, Dimension, LocalizedBorderRadiuses, LocalizedEdgeColors, LocalizedEdges, LocalizedEdgeWidths, LocalizedPadding, LocalizedPosition, Offset, BorderRadiuses, EdgeOutlineWidths, Edges, EdgeWidths, Font, PX, LPX, MarkStyle, OutlineRadiuses, Padding, Area, BorderOptions, OutlineOptions } from "./../../component/units"
+import { Resource } from "./../resource"
+import { BlurOnKeyboardHideMode, CacheMode, ClientAuthenticationHandler, ConsoleMessage, MessageLevel, ContextMenuEditStateFlags, ContextMenuInputFieldType, ContextMenuMediaType, ContextMenuSourceType, ControllerHandler, DataResubmissionHandler, EventResult, FileSelectorMode, FileSelectorParam, FileSelectorResult, FullScreenExitHandler, HitTestType, HttpAuthHandler, JsGeolocation, JsResult, MixedMode, NativeEmbedStatus, NativeMediaPlayerConfig, OnAudioStateChangedEvent, OnConsoleEvent, OnDataResubmittedEvent, OnFaviconReceivedEvent, OnFirstContentfulPaintEvent, OnOverScrollEvent, OnProgressChangeEvent, OnScaleChangeEvent, OnScrollEvent, OnSearchResultReceiveEvent, OnShowFileSelectorEvent, OverScrollMode, PermissionRequest, ProtectedResourceType, RenderExitReason, RenderMode, RenderProcessNotRespondingReason, ScreenCaptureHandler, ScreenCaptureConfig, SslError, SslErrorHandler, ThreatType, ViewportFit, WebCaptureMode, WebContextMenuParam, WebContextMenuResult, WebCookie, WebDarkMode, WebElementType, WebKeyboardAvoidMode, WebKeyboardController, WebLayoutMode, WebNavigationType, WebResourceError, Header, WebResourceRequest, WebResourceResponse, WebResponseType, AdsBlockedDetails, EmbedOptions, FirstMeaningfulPaint, FullScreenEnterEvent, IntelligentTrackingPreventionDetails, JavaScriptProxy, LargestContentfulPaint, LoadCommittedDetails, NativeEmbedVisibilityInfo, NestedScrollOptionsExt, OnAlertEvent, OnBeforeUnloadEvent, OnClientAuthenticationEvent, OnConfirmEvent, OnContextMenuShowEvent, OnDownloadStartEvent, OnErrorReceiveEvent, OnGeolocationShowEvent, OnHttpAuthRequestEvent, OnHttpErrorReceiveEvent, OnInterceptRequestEvent, OnLoadInterceptEvent, OnPageBeginEvent, OnPageEndEvent, OnPageVisibleEvent, OnPermissionRequestEvent, OnPromptEvent, OnRefreshAccessedHistoryEvent, OnRenderExitedEvent, OnResourceLoadEvent, OnScreenCaptureRequestEvent, OnSslErrorEventReceiveEvent, OnTitleReceiveEvent, OnTouchIconUrlReceivedEvent, OnWindowNewEvent, RenderProcessNotRespondingData, ScriptItem, SelectionMenuOptionsExt, SslErrorEvent, WebKeyboardCallbackInfo, WebKeyboardOptions, WebMediaOptions, WebOptions, NativeEmbedInfo, NativeEmbedDataInfo, NativeEmbedTouchInfo } from "./../../component/web"
+import { BreakpointsReference, GridRowDirection, BreakPoints, GridRowColumnOption, GridRowSizeOption, GutterOption, GridRowOptions } from "./../../component/gridRow"
+import { ButtonRole, ButtonStyleMode, ButtonType, ControlSize, ButtonConfiguration, ButtonTriggerClickCallback, ButtonOptions, ButtonLabelStyle } from "./../../component/button"
+import { CalendarAlign, CalendarPickerDialog, CalendarDialogOptions, CalendarOptions } from "./../../component/calendarPicker"
+import { CalendarController, CalendarSelectedDate, CalendarDay, CalendarRequestedData, MonthData, CalendarRequestedMonths, CurrentDayStyle, NonCurrentDayStyle, TodayStyle, WeekStyle, WorkStateStyle } from "./../../component/calendar"
+import { CancelButtonStyle, SearchController, SearchType, CancelButtonSymbolOptions, SearchOptions, IconOptions, SearchButtonOptions, CancelButtonOptions } from "./../../component/search"
+import { CanvasGradient, CanvasPath, CanvasPattern, OffscreenCanvas, ImageBitmap, RenderingContextSettings, OffscreenCanvasRenderingContext2D, Path2D, TextMetrics, DrawingRenderingContext, ImageData, CanvasRenderer, ImageSmoothingQuality, CanvasLineCap, CanvasLineJoin, CanvasDirection, CanvasTextAlign, CanvasTextBaseline, CanvasFillRule, CanvasRenderingContext2D } from "./../../component/canvas"
+import { Matrix2D } from "./../../component/matrix2d"
+import { ChainEdgeEffect, ListItemAlign, ListItemGroupArea, ListScroller, CloseSwipeActionOptions, VisibleListContentInfo, ScrollSnapAlign, ScrollState, StickyStyle, ListOptions, ChainAnimationOptions, ListDividerOptions } from "./../../component/list"
+import { CircleOptions } from "./../../component/circle"
+import { CircleShape, ShapeSize, EllipseShape, PathShape, PathShapeOptions, RectShape, RectShapeOptions, RoundRectShapeOptions } from "./../ohos.arkui.shape"
+import { ColorContent, DynamicRangeMode, ImageContent, ImageInterpolation, ImageRenderMode, ImageRotateOrientation, ImageCompleteEvent, ImageSourceSize, ImageError, ResizableOptions } from "./../../component/image"
+import { ColorMetrics, CornerRadius, DrawContext, Size, LengthMetricsUnit, LengthUnit, ShapeClip, RoundRect, Circle, CommandPath, ShapeMask, Vector2, Vector3, LengthMetrics, Frame } from "./../arkui.Graphics"
+import { ColorMode, LayoutDirection } from "./../../component/stateManagement"
+import { ComponentContent } from "./../arkui.ComponentContent"
+import { ContentModifier } from "./../../handwritten"
+import { ContentType, EnterKeyType, InputType, SubmitEvent, TextInputController, TextInputStyle, PasswordIcon, TextInputOptions, UnderlineColor } from "./../../component/textInput"
+import { Context } from "./../application.Context"
+import { webview } from "./../ohos.web.webview"
+import { curves } from "./../ohos.curves"
+import { CustomDialogController, CustomDialogControllerOptions } from "./../../component/customDialogController"
+import { DataOperationType } from "./../../component/lazyForEach"
+import { DataPanelType, ColorStop, LinearGradient, DataPanelConfiguration, DataPanelOptions, DataPanelShadowOptions } from "./../../component/dataPanel"
+import { DatePickerDialog, DatePickerMode, DatePickerOptions } from "./../../component/datePicker"
+import { DialogAlignment, DialogButtonDirection, AlertDialogButtonOptions } from "./../../component/alertDialog"
+import { DistributionType, DisturbanceFieldShape, ParticleEmitterShape, ParticleType, ParticleUpdater, ParticlePropertyAnimation } from "./../../component/particle"
+import { DpiFollowStrategy, UIExtensionProxy, WindowModeFollowStrategy, UIExtensionOptions } from "./../../component/uiExtensionComponent"
+import { DrawableDescriptor } from "./../ohos.arkui.drawableDescriptor"
+import { image } from "./../ohos.multimedia.image"
+import { drawing } from "./../ohos.graphics.drawing"
+import { common2D } from "./../ohos.graphics.common2D"
+import { EffectDirection, EffectFillStyle, EffectScope, SymbolEffect, SymbolEffectStrategy, SymbolRenderingStrategy, AppearSymbolEffect, BounceSymbolEffect, DisappearSymbolEffect, HierarchicalSymbolEffect, ReplaceSymbolEffect, ScaleSymbolEffect } from "./../../component/symbolglyph"
+import { EllipseOptions } from "./../../component/ellipse"
+import { EventTargetInfo, Gesture, GestureControl, GestureType, GestureMode, GestureJudgeResult, GestureMask, GesturePriority, GestureRecognizer, GestureRecognizerState, LongPressGestureHandlerOptions, GestureEvent, LongPressRecognizer, PanDirection, PanGestureOptions, PanGestureHandlerOptions, PanRecognizer, PinchGestureHandlerOptions, PinchRecognizer, RotationGesture, RotationGestureHandlerOptions, RotationRecognizer, ScrollableTargetInfo, SwipeDirection, SwipeGesture, SwipeGestureHandlerOptions, SwipeRecognizer, TapGestureParameters, TapRecognizer, GestureHandler, FingerInfo, GestureInfo, BaseHandlerOptions, LongPressGestureEvent, BaseGestureEvent, PanGestureEvent, PinchGestureEvent, RotationGestureEvent, SwipeGestureEvent, TapGestureEvent } from "./../../component/gesture"
+import { ExtendableComponent, LifeCycle } from "./../../component/extendableComponent"
+import { UIContext, PromptAction, TargetInfo, TextMenuController } from "./../ohos.arkui.UIContext"
+import { FocusPriority, KeyProcessingMode, FocusBoxStyle } from "./../../component/focus"
+import { FormDimension, FormRenderingMode, FormShape, FormSize, ErrorInformation, FormCallbackInfo, FormInfo } from "./../../component/formComponent"
+import { FrameNode, CrossLanguageOptions, LayoutConstraint } from "./../arkui.FrameNode"
+import { FrictionMotion, ScrollMotion, SpringProp, SpringMotion } from "./../../component/animator"
+import { FullscreenInfo, PlaybackInfo, PlaybackSpeed, PreparedInfo, SeekMode, VideoController, PosterOptions, VideoOptions } from "./../../component/video"
+import { GestureGroupInterface, LongPressGestureInterface, GestureInterface, LongPressGestureInterface_Invoke_Literal, PanGestureInterface, PanGestureInterface_Invoke_Literal, PinchGestureInterface, PinchGestureInterface_Invoke_Literal, TapGestureInterface } from "./../../component/gesture.extra"
+import { GestureStyle, GestureStyleInterface, StyledString, MutableStyledString, StyleOptions, SpanStyle, ImageAttachment, CustomSpan, StyledStringKey, StyledStringMarshallCallback, UserDataSpan, StyledStringUnmarshallCallback, UrlStyle, BaselineOffsetStyle, CustomSpanMeasureInfo, CustomSpanMetrics, CustomSpanDrawInfo, LetterSpacingStyle, LineHeightStyle, TextShadowStyle, DecorationStyle, DecorationStyleInterface, TextStyle, TextStyleInterface, ImageAttachmentLayoutStyle, ParagraphStyle, ParagraphStyleInterface, BackgroundColorStyle, ColorFilterType, ImageAttachmentInterface, AttachmentType, ResourceImageAttachmentOptions, StyledStringValue } from "./../../component/styledString"
+import { GridDirection, GridItemAlignment, ComputedBarAttribute, GridLayoutOptions } from "./../../component/grid"
+import { GridItemStyle, GridItemOptions } from "./../../component/gridItem"
+import { ImageAnalyzerType, ImageAnalyzerController, ImageAIOptions, ImageAnalyzerConfig } from "./../../component/imageCommon"
+import { ImmersiveMode, LevelMode, LevelOrder } from "./../ohos.promptAction"
+import { IndexerAlign, AlphabetIndexerOptions } from "./../../component/alphabetIndexer"
+import { IndicatorComponentController } from "./../../component/indicatorcomponent"
+import { IntentionCode } from "./../ohos.multimodalInput.intentionCode"
+import { ItemState } from "./../../component/stepperItem"
+import { LayoutCallback, PageLifeCycle } from "./../../component/customComponent"
+import { LayoutMode, SelectedMode, TabBarSymbol, TabBarIconStyle, TabBarOptions, BoardStyle, SubTabBarIndicatorStyle, TabBarLabelStyle, BottomTabBarStyle, SubTabBarStyle } from "./../../component/tabContent"
+import { LinearIndicatorController, LinearIndicatorStartOptions, LinearIndicatorStyle } from "./../../component/linearindicator"
+import { LineOptions, ShapePoint } from "./../../component/line"
+import { ListItemGroupStyle, ListItemGroupOptions } from "./../../component/listItemGroup"
+import { ListItemStyle, SwipeActionState, SwipeEdgeEffect, ListItemOptions, SwipeActionItem, SwipeActionOptions } from "./../../component/listItem"
+import { Scroller, ScrollAlign, OffsetResult, OnScrollFrameBeginHandlerResult, ScrollDirection, ScrollOptions, ScrollEdgeOptions, ScrollPageOptions, ScrollToIndexOptions, ScrollAnimationOptions, OffsetOptions, ScrollSnapOptions } from "./../../component/scroll"
+import { LoadingProgressConfiguration, LoadingProgressStyle } from "./../../component/loadingProgress"
+import { LocationButtonOnClickResult, LocationDescription, LocationIconStyle } from "./../../component/locationButton"
+import { MarqueeStartPolicy, MarqueeState, TextController, TextOptions, TextOverflowOptions, TextResponseType, TextSpanType, TextMarqueeOptions } from "./../../component/text"
+import { matrix4 } from "./../ohos.matrix4"
+import { NavDestinationActiveReason, NavDestinationMode, NavigationSystemTransitionType, NavDestinationTransition, NavDestinationContext, NestedScrollInfo, RouteMapConfig, NavDestinationCommonTitle, NavDestinationCustomTitle } from "./../../component/navDestination"
+import { NavigationType } from "./../../component/navigator"
+import { NodeContent } from "./../arkui.nodecontent"
+import { Content } from "./../ohos.arkui.node"
+import { NodeController } from "./../arkui.NodeController"
+import { OnFoldStatusChangeInfo, FolderStackOptions, HoverEventParam } from "./../../component/folderStack"
+import { PasteButtonOnClickResult, PasteDescription, PasteIconStyle } from "./../../component/pasteButton"
+import { PathOptions } from "./../../component/path"
+import { PatternLockChallengeResult, PatternLockController, CircleStyleOptions } from "./../../component/patternLock"
+import { pointer } from "./../ohos.multimodalInput.pointer"
+import { PolygonOptions } from "./../../component/polygon"
+import { PolylineOptions } from "./../../component/polyline"
+import { ProgressConfiguration, ProgressStatus, ProgressStyle, ProgressType, ProgressOptions, LinearStyleOptions, ScanEffectOptions, CommonProgressStyleOptions, ProgressStyleOptions, RingStyleOptions, CapsuleStyleOptions } from "./../../component/progress"
+import { RadioIndicatorType, RadioConfiguration, RadioOptions, RadioStyle } from "./../../component/radio"
+import { RefreshStatus, RefreshOptions } from "./../../component/refresh"
+import { RichEditorBaseController, RichEditorTextStyle, RichEditorParagraphResult, RichEditorSpan, RichEditorController, RichEditorTextSpanOptions, RichEditorImageSpanOptions, RichEditorBuilderSpanOptions, RichEditorSymbolSpanOptions, RichEditorUpdateTextSpanStyleOptions, RichEditorUpdateImageSpanStyleOptions, RichEditorUpdateSymbolSpanStyleOptions, RichEditorParagraphStyleOptions, RichEditorRange, RichEditorImageSpanResult, RichEditorTextSpanResult, RichEditorSelection, RichEditorDeleteDirection, RichEditorOptions, RichEditorResponseType, RichEditorSpanType, RichEditorStyledStringController, RichEditorStyledStringOptions, KeyboardOptions, PreviewMenuOptions, RichEditorDeleteValue, RichEditorGesture, RichEditorInsertValue, RichEditorSpanPosition, CopyEvent, CutEvent, PasteEvent, RichEditorChangeValue, RichEditorSymbolSpanStyle, RichEditorSpanStyleOptions, RichEditorUrlStyle, SelectionMenuOptions, MenuOnAppearCallback, MenuCallback, LeadingMarginPlaceholder, PlaceholderStyle, RichEditorLayoutStyle, RichEditorParagraphStyle, RichEditorImageSpanStyle, RichEditorImageSpanStyleResult, RichEditorTextStyleResult, OnHoverCallback } from "./../../component/richEditor"
+import { CustomBuilder } from "./../../component/builder"
+import { RootSceneSession } from "./../../component/rootScene"
+import { RoundedRectOptions, RadiusItem, RectOptions } from "./../../component/rect"
+import { RouteType, SlideEffect } from "./../../component/pageTransition"
+import { RowOptionsV2, RowOptions } from "./../../component/row"
+import { RRect, WindowAnimationTarget } from "./../../component/remoteWindow"
+import { SaveButtonOnClickResult, SaveDescription, SaveIconStyle } from "./../../component/saveButton"
+import { ScrollBarDirection, ScrollBarOptions } from "./../../component/scrollBar"
+import { SecurityComponentLayoutDirection } from "./../../component/securityComponent"
+import { SelectStatus, CheckboxGroupOptions, CheckboxGroupResult } from "./../../component/checkboxgroup"
+import { SideBarContainerType, SideBarPosition, ButtonIconOptions, ButtonStyle } from "./../../component/sidebar"
+import { SliderBlockType, SliderChangeMode, SliderInteraction, SliderStyle, SlideRange, SliderConfiguration, SliderTriggerChangeCallback, SliderOptions, SliderBlockStyle } from "./../../component/slider"
+import { SubMenuExpandingMode } from "./../../component/menu"
+import { SwiperAnimationEvent, SwiperAnimationMode, SwiperContentTransitionProxy, SwiperContentWillScrollResult, SwiperController, SwiperDisplayMode, SwiperNestedScrollMode, AutoPlayOptions, SwiperAutoFill, SwiperContentAnimatedTransition, ArrowStyle, DotIndicator, Indicator, DigitIndicator } from "./../../component/swiper"
+import { SymbolGlyphModifier } from "./../arkui.SymbolGlyphModifier"
+import { text } from "./../ohos.graphics.text"
+import { TextAreaController, TextAreaType, TextAreaOptions } from "./../../component/textArea"
+import { TextClockConfiguration, TextClockController, TextClockOptions } from "./../../component/textClock"
+import { TextModifier } from "./../arkui.TextModifier"
+import { TextPickerDialog, TextPickerDialogOptions, TextCascadePickerRangeContent, TextPickerRangeContent, TextPickerOptions, TextPickerResult, DividerOptions, TextPickerTextStyle } from "./../../component/textPicker"
+import { TextTimerConfiguration, TextTimerController, TextTimerOptions } from "./../../component/textTimer"
+import { ThemeControl, CustomTheme, Colors } from "./../ohos.arkui.theme"
+import { TimePickerDialog, TimePickerFormat, TimePickerResult, TimePickerOptions } from "./../../component/timePicker"
+import { ToggleType, ToggleConfiguration, ToggleOptions, SwitchStyle } from "./../../component/toggle"
+import { common, Context_getGroupDir_Callback } from "./../ohos.app.ability.common"
+import { uiEffect } from "./../ohos.graphics.uiEffect"
+import { unifiedDataChannel } from "./../ohos.data.unifiedDataChannel"
+import { uniformTypeDescriptor } from "./../ohos.data.uniformTypeDescriptor"
+import { WaterFlowLayoutMode, SectionOptions, WaterFlowSections, WaterFlowOptions, GetItemMainSizeByIndex } from "./../../component/waterFlow"
+import { window } from "./../ohos.window"
+import { ASTCResource } from "./../../component/mediaCachedImage"
+import { BorderRadiuses_graphics, RenderNode } from "./../arkui.RenderNode"
+import { BusinessError } from "./../ohos.base"
+import { CheckBoxConfiguration, CheckboxOptions } from "./../../component/checkbox"
+import { ColumnOptions, ColumnOptionsV2 } from "./../../component/column"
+import { CompatibleComponentInfo } from "./../../component/interop"
+import { DismissDialogAction, SheetInfo } from "./../../component/actionSheet"
+import { font } from "./../ohos.font"
+import { FormLinkOptions } from "./../../component/formLink"
+import { GaugeConfiguration, GaugeOptions, GaugeShadowOptions, GaugeIndicatorOptions } from "./../../component/gauge"
+import { GridColColumnOption, GridColOptions } from "./../../component/gridCol"
+import { ImageLoadResult } from "./../../component/imageSpan"
+import { intl } from "./../ohos.intl"
+import { MarqueeOptions } from "./../../component/marquee"
+import { PluginComponentTemplate, PluginErrorData, PluginComponentOptions } from "./../../component/pluginComponent"
+import { RatingConfiguration, RatingOptions, StarStyleOptions } from "./../../component/rating"
+import { StackOptions } from "./../../component/stack"
+import { StepperOptions } from "./../../component/stepper"
+import { SurfaceRect, SurfaceRotationOptions, XComponentController, NativeXComponentParameters, XComponentOptions, XComponentParameter } from "./../../component/xcomponent"
+import { Want } from "./../ohos.app.ability.Want"
+import { FlexSpaceOptions, FlexOptions } from "./../../component/flex"
+import { ImageFrameInfo } from "./../../component/imageAnimator"
+import { MenuItemGroupOptions } from "./../../component/menuItemGroup"
+import { MenuItemOptions } from "./../../component/menuItem"
+import { ColumnSplitDividerStyle } from "./../../component/columnSplit"
+import { ViewportRect } from "./../../component/shape"
+import { TextBackgroundStyle } from "./../../component/span"
+export class TypeChecker {
+    static typeInstanceOf<T>(value: Object, prop: string): boolean {
+        return value.hasOwnProperty(prop)
+    }
+    static typeCast<T>(value: Object): any {
+        return value as unknown as T
+    }
+    static isNativeBuffer(value: Object): boolean {
+        return value instanceof ArrayBuffer
+    }
+    static isAccessibilityHoverEvent(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AccessibilityHoverEvent")
+        }
+    }
+    static isAccessibilityHoverType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AccessibilityHoverType.HOVER_ENTER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityHoverType.HOVER_MOVE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityHoverType.HOVER_EXIT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityHoverType.HOVER_CANCEL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AccessibilityHoverType")
+        }
+    }
+    static isAccessibilityOptions(value: Object | string | number | undefined | boolean, duplicated_accessibilityPreferred: boolean): boolean {
+        if ((!duplicated_accessibilityPreferred) && (value?.hasOwnProperty("accessibilityPreferred"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AccessibilityOptions")
+        }
+    }
+    static isAccessibilityRoleType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AccessibilityRoleType.ACTION_SHEET)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ALERT_DIALOG)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.INDEXER_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.BADGE_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.BLANK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.BUTTON)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.BACK_BUTTON)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SHEET_DRAG_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CALENDAR_PICKER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CALENDAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CANVAS)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CANVAS_GRADIENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CANVAS_PATTERN)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CHECKBOX)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CHECKBOX_GROUP)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CIRCLE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.COLUMN_SPLIT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.COLUMN)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CANVAS_RENDERING_CONTEXT_2D)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CHART)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.COUNTER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.CONTAINER_MODAL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.DATA_PANEL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.DATE_PICKER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.DIALOG)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.DIVIDER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.DRAG_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.EFFECT_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ELLIPSE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.FLEX)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.FLOW_ITEM)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.FORM_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.FORM_LINK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GAUGE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GRID)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GRID_COL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GRID_CONTAINER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GRID_ITEM)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.GRID_ROW)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.HYPERLINK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.IMAGE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.IMAGE_ANIMATOR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.IMAGE_BITMAP)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.IMAGE_DATA)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.IMAGE_SPAN)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LABEL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LINE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LIST)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LIST_ITEM)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LIST_ITEM_GROUP)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.LOADING_PROGRESS)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.MARQUEE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.MATRIX2D)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.MENU)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.MENU_ITEM)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.MENU_ITEM_GROUP)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAV_DESTINATION)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAV_ROUTER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAVIGATION)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAVIGATION_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAVIGATION_MENU)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.NAVIGATOR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.OFFSCREEN_CANVAS)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.OFFSCREEN_CANVAS_RENDERING_CONTEXT2D)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.OPTION)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PANEL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PAPER_PAGE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PATH)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PATH2D)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PATTERN_LOCK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PICKER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PICKER_VIEW)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PLUGIN_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.POLYGON)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.POLYLINE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.POPUP)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.PROGRESS)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.QRCODE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RADIO)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RATING)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RECT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.REFRESH)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RELATIVE_CONTAINER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.REMOTE_WINDOW)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RICH_EDITOR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.RICH_TEXT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ROLE_PAGER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ROW)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ROW_SPLIT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SCROLL)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SCROLL_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SEARCH)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SEARCH_FIELD)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SELECT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SHAPE)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SIDEBAR_CONTAINER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SLIDER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SPAN)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.STACK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.STEPPER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.STEPPER_ITEM)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SWIPER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SWIPER_INDICATOR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SWITCH)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.SYMBOL_GLYPH)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TAB_CONTENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TAB_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TABS)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_CLOCK)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_ENTRY)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_INPUT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_PICKER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_TIMER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_AREA)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TEXT_FIELD)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TIME_PICKER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TITLE_BAR)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.TOGGLER)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.UI_EXTENSION_COMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.VIDEO)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.WATER_FLOW)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.WEB)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.XCOMPONENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilityRoleType.ROLE_NONE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AccessibilityRoleType")
+        }
+    }
+    static isAccessibilitySamePageMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AccessibilitySamePageMode.SEMI_SILENT)) {
+            return true
+        }
+        else if ((value) === (AccessibilitySamePageMode.FULL_SILENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AccessibilitySamePageMode")
+        }
+    }
+    static isAdaptiveColor(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AdaptiveColor.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (AdaptiveColor.AVERAGE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AdaptiveColor")
+        }
+    }
+    static isAdsBlockedDetails(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_adsBlocked: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_adsBlocked) && (value?.hasOwnProperty("adsBlocked"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AdsBlockedDetails")
+        }
+    }
+    static isAlignment(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Alignment.TopStart)) {
+            return true
+        }
+        else if ((value) === (Alignment.Top)) {
+            return true
+        }
+        else if ((value) === (Alignment.TopEnd)) {
+            return true
+        }
+        else if ((value) === (Alignment.Start)) {
+            return true
+        }
+        else if ((value) === (Alignment.Center)) {
+            return true
+        }
+        else if ((value) === (Alignment.End)) {
+            return true
+        }
+        else if ((value) === (Alignment.BottomStart)) {
+            return true
+        }
+        else if ((value) === (Alignment.Bottom)) {
+            return true
+        }
+        else if ((value) === (Alignment.BottomEnd)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Alignment")
+        }
+    }
+    static isAlignRuleOption(value: Object | string | number | undefined | boolean, duplicated__stub: boolean): boolean {
+        if ((!duplicated__stub) && (value?.hasOwnProperty("_stub"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AlignRuleOption")
+        }
+    }
+    static isAlphabetIndexerOptions(value: Object | string | number | undefined | boolean, duplicated_arrayValue: boolean, duplicated_selected: boolean): boolean {
+        if ((!duplicated_arrayValue) && (value?.hasOwnProperty("arrayValue"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AlphabetIndexerOptions")
+        }
+    }
+    static isAnimateParam(value: Object | string | number | undefined | boolean, duplicated_duration: boolean, duplicated_tempo: boolean, duplicated_curve: boolean, duplicated_delay: boolean, duplicated_iterations: boolean, duplicated_playMode: boolean, duplicated_onFinish: boolean, duplicated_finishCallbackType: boolean, duplicated_expectedFrameRateRange: boolean): boolean {
+        if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else if ((!duplicated_tempo) && (value?.hasOwnProperty("tempo"))) {
+            return true
+        }
+        else if ((!duplicated_curve) && (value?.hasOwnProperty("curve"))) {
+            return true
+        }
+        else if ((!duplicated_delay) && (value?.hasOwnProperty("delay"))) {
+            return true
+        }
+        else if ((!duplicated_iterations) && (value?.hasOwnProperty("iterations"))) {
+            return true
+        }
+        else if ((!duplicated_playMode) && (value?.hasOwnProperty("playMode"))) {
+            return true
+        }
+        else if ((!duplicated_onFinish) && (value?.hasOwnProperty("onFinish"))) {
+            return true
+        }
+        else if ((!duplicated_finishCallbackType) && (value?.hasOwnProperty("finishCallbackType"))) {
+            return true
+        }
+        else if ((!duplicated_expectedFrameRateRange) && (value?.hasOwnProperty("expectedFrameRateRange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AnimateParam")
+        }
+    }
+    static isAnimationMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AnimationMode.CONTENT_FIRST)) {
+            return true
+        }
+        else if ((value) === (AnimationMode.ACTION_FIRST)) {
+            return true
+        }
+        else if ((value) === (AnimationMode.NO_ANIMATION)) {
+            return true
+        }
+        else if ((value) === (AnimationMode.CONTENT_FIRST_WITH_JUMP)) {
+            return true
+        }
+        else if ((value) === (AnimationMode.ACTION_FIRST_WITH_JUMP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AnimationMode")
+        }
+    }
+    static isAnimationStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AnimationStatus.Initial)) {
+            return true
+        }
+        else if ((value) === (AnimationStatus.Running)) {
+            return true
+        }
+        else if ((value) === (AnimationStatus.Paused)) {
+            return true
+        }
+        else if ((value) === (AnimationStatus.Stopped)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AnimationStatus")
+        }
+    }
+    static isAppearSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_scope: boolean): boolean {
+        if ((!duplicated_scope) && (value?.hasOwnProperty("scope"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AppearSymbolEffect")
+        }
+    }
+    static isAppRotation(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AppRotation.ROTATION_0)) {
+            return true
+        }
+        else if ((value) === (AppRotation.ROTATION_90)) {
+            return true
+        }
+        else if ((value) === (AppRotation.ROTATION_180)) {
+            return true
+        }
+        else if ((value) === (AppRotation.ROTATION_270)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AppRotation")
+        }
+    }
+    static isArea(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_position: boolean, duplicated_globalPosition: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else if ((!duplicated_globalPosition) && (value?.hasOwnProperty("globalPosition"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Area")
+        }
+    }
+    static isArrowPointPosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ArrowPointPosition.START)) {
+            return true
+        }
+        else if ((value) === (ArrowPointPosition.CENTER)) {
+            return true
+        }
+        else if ((value) === (ArrowPointPosition.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ArrowPointPosition")
+        }
+    }
+    static isArrowPosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ArrowPosition.END)) {
+            return true
+        }
+        else if ((value) === (ArrowPosition.START)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ArrowPosition")
+        }
+    }
+    static isArrowStyle(value: Object | string | number | undefined | boolean, duplicated_showBackground: boolean, duplicated_isSidebarMiddle: boolean, duplicated_backgroundSize: boolean, duplicated_backgroundColor: boolean, duplicated_arrowSize: boolean, duplicated_arrowColor: boolean): boolean {
+        if ((!duplicated_showBackground) && (value?.hasOwnProperty("showBackground"))) {
+            return true
+        }
+        else if ((!duplicated_isSidebarMiddle) && (value?.hasOwnProperty("isSidebarMiddle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundSize) && (value?.hasOwnProperty("backgroundSize"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_arrowSize) && (value?.hasOwnProperty("arrowSize"))) {
+            return true
+        }
+        else if ((!duplicated_arrowColor) && (value?.hasOwnProperty("arrowColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ArrowStyle")
+        }
+    }
+    static isASTCResource(value: Object | string | number | undefined | boolean, duplicated_sources: boolean, duplicated_column: boolean): boolean {
+        if ((!duplicated_sources) && (value?.hasOwnProperty("sources"))) {
+            return true
+        }
+        else if ((!duplicated_column) && (value?.hasOwnProperty("column"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ASTCResource")
+        }
+    }
+    static isAsymmetricTransitionOption(value: Object | string | number | undefined | boolean, duplicated_appear: boolean, duplicated_disappear: boolean): boolean {
+        if ((!duplicated_appear) && (value?.hasOwnProperty("appear"))) {
+            return true
+        }
+        else if ((!duplicated_disappear) && (value?.hasOwnProperty("disappear"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AsymmetricTransitionOption")
+        }
+    }
+    static isAutoCapitalizationMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AutoCapitalizationMode.NONE)) {
+            return true
+        }
+        else if ((value) === (AutoCapitalizationMode.WORDS)) {
+            return true
+        }
+        else if ((value) === (AutoCapitalizationMode.SENTENCES)) {
+            return true
+        }
+        else if ((value) === (AutoCapitalizationMode.ALL_CHARACTERS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AutoCapitalizationMode")
+        }
+    }
+    static isAutoPlayOptions(value: Object | string | number | undefined | boolean, duplicated_stopWhenTouched: boolean): boolean {
+        if ((!duplicated_stopWhenTouched) && (value?.hasOwnProperty("stopWhenTouched"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AutoPlayOptions")
+        }
+    }
+    static isAvoidanceMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AvoidanceMode.COVER_TARGET)) {
+            return true
+        }
+        else if ((value) === (AvoidanceMode.AVOID_AROUND_TARGET)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AvoidanceMode")
+        }
+    }
+    static isAxis(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Axis.Vertical)) {
+            return true
+        }
+        else if ((value) === (Axis.Horizontal)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Axis")
+        }
+    }
+    static isAxisAction(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AxisAction.NONE)) {
+            return true
+        }
+        else if ((value) === (AxisAction.BEGIN)) {
+            return true
+        }
+        else if ((value) === (AxisAction.UPDATE)) {
+            return true
+        }
+        else if ((value) === (AxisAction.END)) {
+            return true
+        }
+        else if ((value) === (AxisAction.CANCEL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AxisAction")
+        }
+    }
+    static isAxisEvent(value: Object | string | number | undefined | boolean, duplicated_action: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_scrollStep: boolean, duplicated_propagation: boolean): boolean {
+        if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_propagation) && (value?.hasOwnProperty("propagation"))) {
+            return true
+        }
+        else if ((!duplicated_scrollStep) && (value?.hasOwnProperty("scrollStep"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AxisEvent")
+        }
+    }
+    static isAxisModel(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (AxisModel.ABS_X)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_Y)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_Z)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_RZ)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_GAS)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_BRAKE)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_HAT0X)) {
+            return true
+        }
+        else if ((value) === (AxisModel.ABS_HAT0Y)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof AxisModel")
+        }
+    }
+    static isBackgroundBlurStyleOptions(value: Object | string | number | undefined | boolean, duplicated_policy: boolean, duplicated_inactiveColor: boolean): boolean {
+        if ((!duplicated_policy) && (value?.hasOwnProperty("policy"))) {
+            return true
+        }
+        else if ((!duplicated_inactiveColor) && (value?.hasOwnProperty("inactiveColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundBlurStyleOptions")
+        }
+    }
+    static isBackgroundBrightnessOptions(value: Object | string | number | undefined | boolean, duplicated_rate: boolean, duplicated_lightUpDegree: boolean): boolean {
+        if ((!duplicated_rate) && (value?.hasOwnProperty("rate"))) {
+            return true
+        }
+        else if ((!duplicated_lightUpDegree) && (value?.hasOwnProperty("lightUpDegree"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundBrightnessOptions")
+        }
+    }
+    static isBackgroundColorStyle(value: Object | string | number | undefined | boolean, duplicated_textBackgroundStyle: boolean): boolean {
+        if ((!duplicated_textBackgroundStyle) && (value?.hasOwnProperty("textBackgroundStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundColorStyle")
+        }
+    }
+    static isBackgroundEffectOptions(value: Object | string | number | undefined | boolean, duplicated_radius: boolean, duplicated_saturation: boolean, duplicated_brightness: boolean, duplicated_color: boolean, duplicated_adaptiveColor: boolean, duplicated_blurOptions: boolean, duplicated_policy: boolean, duplicated_inactiveColor: boolean): boolean {
+        if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_saturation) && (value?.hasOwnProperty("saturation"))) {
+            return true
+        }
+        else if ((!duplicated_brightness) && (value?.hasOwnProperty("brightness"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_adaptiveColor) && (value?.hasOwnProperty("adaptiveColor"))) {
+            return true
+        }
+        else if ((!duplicated_blurOptions) && (value?.hasOwnProperty("blurOptions"))) {
+            return true
+        }
+        else if ((!duplicated_policy) && (value?.hasOwnProperty("policy"))) {
+            return true
+        }
+        else if ((!duplicated_inactiveColor) && (value?.hasOwnProperty("inactiveColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundEffectOptions")
+        }
+    }
+    static isBackgroundImageOptions(value: Object | string | number | undefined | boolean, duplicated_syncLoad: boolean, duplicated_repeat: boolean): boolean {
+        if ((!duplicated_syncLoad) && (value?.hasOwnProperty("syncLoad"))) {
+            return true
+        }
+        else if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundImageOptions")
+        }
+    }
+    static isBackgroundOptions(value: Object | string | number | undefined | boolean, duplicated_align: boolean): boolean {
+        if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BackgroundOptions")
+        }
+    }
+    static isBadgeParamWithNumber(value: Object | string | number | undefined | boolean, duplicated_count: boolean, duplicated_maxCount: boolean): boolean {
+        if ((!duplicated_count) && (value?.hasOwnProperty("count"))) {
+            return true
+        }
+        else if ((!duplicated_maxCount) && (value?.hasOwnProperty("maxCount"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BadgeParamWithNumber")
+        }
+    }
+    static isBadgeParamWithString(value: Object | string | number | undefined | boolean, duplicated_value: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BadgeParamWithString")
+        }
+    }
+    static isBadgePosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BadgePosition.RightTop)) {
+            return true
+        }
+        else if ((value) === (BadgePosition.Right)) {
+            return true
+        }
+        else if ((value) === (BadgePosition.Left)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BadgePosition")
+        }
+    }
+    static isBadgeStyle(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_fontSize: boolean, duplicated_badgeSize: boolean, duplicated_badgeColor: boolean, duplicated_borderColor: boolean, duplicated_borderWidth: boolean, duplicated_fontWeight: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_badgeSize) && (value?.hasOwnProperty("badgeSize"))) {
+            return true
+        }
+        else if ((!duplicated_badgeColor) && (value?.hasOwnProperty("badgeColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderColor) && (value?.hasOwnProperty("borderColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BadgeStyle")
+        }
+    }
+    static isBarGridColumnOptions(value: Object | string | number | undefined | boolean, duplicated_sm: boolean, duplicated_md: boolean, duplicated_lg: boolean, duplicated_margin: boolean, duplicated_gutter: boolean): boolean {
+        if ((!duplicated_sm) && (value?.hasOwnProperty("sm"))) {
+            return true
+        }
+        else if ((!duplicated_md) && (value?.hasOwnProperty("md"))) {
+            return true
+        }
+        else if ((!duplicated_lg) && (value?.hasOwnProperty("lg"))) {
+            return true
+        }
+        else if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_gutter) && (value?.hasOwnProperty("gutter"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarGridColumnOptions")
+        }
+    }
+    static isBarMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BarMode.Scrollable)) {
+            return true
+        }
+        else if ((value) === (BarMode.Fixed)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarMode")
+        }
+    }
+    static isBarPosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BarPosition.Start)) {
+            return true
+        }
+        else if ((value) === (BarPosition.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarPosition")
+        }
+    }
+    static isBarrierDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BarrierDirection.LEFT)) {
+            return true
+        }
+        else if ((value) === (BarrierDirection.RIGHT)) {
+            return true
+        }
+        else if ((value) === (BarrierDirection.TOP)) {
+            return true
+        }
+        else if ((value) === (BarrierDirection.BOTTOM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarrierDirection")
+        }
+    }
+    static isBarrierStyle(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_direction: boolean, duplicated_referencedId: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_referencedId) && (value?.hasOwnProperty("referencedId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarrierStyle")
+        }
+    }
+    static isBarState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BarState.Off)) {
+            return true
+        }
+        else if ((value) === (BarState.Auto)) {
+            return true
+        }
+        else if ((value) === (BarState.On)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarState")
+        }
+    }
+    static isBarStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BarStyle.STANDARD)) {
+            return true
+        }
+        else if ((value) === (BarStyle.STACK)) {
+            return true
+        }
+        else if ((value) === (BarStyle.SAFE_AREA_PADDING)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BarStyle")
+        }
+    }
+    static isBaseContext(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof BaseContext")
+    }
+    static isBaseEvent(value: Object | string | number | undefined | boolean, duplicated_target: boolean, duplicated_timestamp: boolean, duplicated_source: boolean, duplicated_axisHorizontal: boolean, duplicated_axisVertical: boolean, duplicated_pressure: boolean, duplicated_tiltX: boolean, duplicated_tiltY: boolean, duplicated_rollAngle: boolean, duplicated_sourceTool: boolean, duplicated_getModifierKeyState: boolean, duplicated_deviceId: boolean, duplicated_targetDisplayId: boolean): boolean {
+        if ((!duplicated_target) && (value?.hasOwnProperty("target"))) {
+            return true
+        }
+        else if ((!duplicated_timestamp) && (value?.hasOwnProperty("timestamp"))) {
+            return true
+        }
+        else if ((!duplicated_source) && (value?.hasOwnProperty("source"))) {
+            return true
+        }
+        else if ((!duplicated_pressure) && (value?.hasOwnProperty("pressure"))) {
+            return true
+        }
+        else if ((!duplicated_tiltX) && (value?.hasOwnProperty("tiltX"))) {
+            return true
+        }
+        else if ((!duplicated_tiltY) && (value?.hasOwnProperty("tiltY"))) {
+            return true
+        }
+        else if ((!duplicated_sourceTool) && (value?.hasOwnProperty("sourceTool"))) {
+            return true
+        }
+        else if ((!duplicated_axisHorizontal) && (value?.hasOwnProperty("axisHorizontal"))) {
+            return true
+        }
+        else if ((!duplicated_axisVertical) && (value?.hasOwnProperty("axisVertical"))) {
+            return true
+        }
+        else if ((!duplicated_rollAngle) && (value?.hasOwnProperty("rollAngle"))) {
+            return true
+        }
+        else if ((!duplicated_getModifierKeyState) && (value?.hasOwnProperty("getModifierKeyState"))) {
+            return true
+        }
+        else if ((!duplicated_deviceId) && (value?.hasOwnProperty("deviceId"))) {
+            return true
+        }
+        else if ((!duplicated_targetDisplayId) && (value?.hasOwnProperty("targetDisplayId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BaseEvent")
+        }
+    }
+    static isBaseGestureEvent(value: Object | string | number | undefined | boolean, duplicated_fingerList: boolean): boolean {
+        if ((!duplicated_fingerList) && (value?.hasOwnProperty("fingerList"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BaseGestureEvent")
+        }
+    }
+    static isBaselineOffsetStyle(value: Object | string | number | undefined | boolean, duplicated_baselineOffset: boolean): boolean {
+        if ((!duplicated_baselineOffset) && (value?.hasOwnProperty("baselineOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BaselineOffsetStyle")
+        }
+    }
+    static isBaseShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof BaseShape")
+    }
+    static isBias(value: Object | string | number | undefined | boolean, duplicated_horizontal: boolean, duplicated_vertical: boolean): boolean {
+        if ((!duplicated_horizontal) && (value?.hasOwnProperty("horizontal"))) {
+            return true
+        }
+        else if ((!duplicated_vertical) && (value?.hasOwnProperty("vertical"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Bias")
+        }
+    }
+    static isBlendApplyType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BlendApplyType.FAST)) {
+            return true
+        }
+        else if ((value) === (BlendApplyType.OFFSCREEN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlendApplyType")
+        }
+    }
+    static isBlendMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BlendMode.NONE)) {
+            return true
+        }
+        else if ((value) === (BlendMode.CLEAR)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SRC)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DST)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SRC_OVER)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DST_OVER)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SRC_IN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DST_IN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SRC_OUT)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DST_OUT)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SRC_ATOP)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DST_ATOP)) {
+            return true
+        }
+        else if ((value) === (BlendMode.XOR)) {
+            return true
+        }
+        else if ((value) === (BlendMode.PLUS)) {
+            return true
+        }
+        else if ((value) === (BlendMode.MODULATE)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SCREEN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.OVERLAY)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DARKEN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.LIGHTEN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.COLOR_DODGE)) {
+            return true
+        }
+        else if ((value) === (BlendMode.COLOR_BURN)) {
+            return true
+        }
+        else if ((value) === (BlendMode.HARD_LIGHT)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SOFT_LIGHT)) {
+            return true
+        }
+        else if ((value) === (BlendMode.DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (BlendMode.EXCLUSION)) {
+            return true
+        }
+        else if ((value) === (BlendMode.MULTIPLY)) {
+            return true
+        }
+        else if ((value) === (BlendMode.HUE)) {
+            return true
+        }
+        else if ((value) === (BlendMode.SATURATION)) {
+            return true
+        }
+        else if ((value) === (BlendMode.COLOR)) {
+            return true
+        }
+        else if ((value) === (BlendMode.LUMINOSITY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlendMode")
+        }
+    }
+    static isBlurOnKeyboardHideMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BlurOnKeyboardHideMode.SILENT)) {
+            return true
+        }
+        else if ((value) === (BlurOnKeyboardHideMode.BLUR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlurOnKeyboardHideMode")
+        }
+    }
+    static isBlurOptions(value: Object | string | number | undefined | boolean, duplicated_grayscale: boolean): boolean {
+        if ((!duplicated_grayscale) && (value?.hasOwnProperty("grayscale"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlurOptions")
+        }
+    }
+    static isBlurStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BlurStyle.Thin)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.Regular)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.Thick)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.BACKGROUND_THIN)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.BACKGROUND_REGULAR)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.BACKGROUND_THICK)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.BACKGROUND_ULTRA_THICK)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.NONE)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.COMPONENT_ULTRA_THIN)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.COMPONENT_THIN)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.COMPONENT_REGULAR)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.COMPONENT_THICK)) {
+            return true
+        }
+        else if ((value) === (BlurStyle.COMPONENT_ULTRA_THICK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlurStyle")
+        }
+    }
+    static isBlurStyleActivePolicy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BlurStyleActivePolicy.FOLLOWS_WINDOW_ACTIVE_STATE)) {
+            return true
+        }
+        else if ((value) === (BlurStyleActivePolicy.ALWAYS_ACTIVE)) {
+            return true
+        }
+        else if ((value) === (BlurStyleActivePolicy.ALWAYS_INACTIVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BlurStyleActivePolicy")
+        }
+    }
+    static isBoardStyle(value: Object | string | number | undefined | boolean, duplicated_borderRadius: boolean): boolean {
+        if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BoardStyle")
+        }
+    }
+    static isBorderImageOption(value: Object | string | number | undefined | boolean, duplicated_slice: boolean, duplicated_repeat: boolean, duplicated_source: boolean, duplicated_width: boolean, duplicated_outset: boolean, duplicated_fill: boolean): boolean {
+        if ((!duplicated_slice) && (value?.hasOwnProperty("slice"))) {
+            return true
+        }
+        else if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else if ((!duplicated_source) && (value?.hasOwnProperty("source"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_outset) && (value?.hasOwnProperty("outset"))) {
+            return true
+        }
+        else if ((!duplicated_fill) && (value?.hasOwnProperty("fill"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BorderImageOption")
+        }
+    }
+    static isBorderOptions(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_color: boolean, duplicated_radius: boolean, duplicated_style: boolean, duplicated_dashGap: boolean, duplicated_dashWidth: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_dashGap) && (value?.hasOwnProperty("dashGap"))) {
+            return true
+        }
+        else if ((!duplicated_dashWidth) && (value?.hasOwnProperty("dashWidth"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BorderOptions")
+        }
+    }
+    static isBorderRadiuses(value: Object | string | number | undefined | boolean, duplicated_topLeft: boolean, duplicated_topRight: boolean, duplicated_bottomLeft: boolean, duplicated_bottomRight: boolean): boolean {
+        if ((!duplicated_topLeft) && (value?.hasOwnProperty("topLeft"))) {
+            return true
+        }
+        else if ((!duplicated_topRight) && (value?.hasOwnProperty("topRight"))) {
+            return true
+        }
+        else if ((!duplicated_bottomLeft) && (value?.hasOwnProperty("bottomLeft"))) {
+            return true
+        }
+        else if ((!duplicated_bottomRight) && (value?.hasOwnProperty("bottomRight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BorderRadiuses")
+        }
+    }
+    static isBorderRadiuses_graphics(value: Object | string | number | undefined | boolean, duplicated_topLeft: boolean, duplicated_topRight: boolean, duplicated_bottomLeft: boolean, duplicated_bottomRight: boolean): boolean {
+        if ((!duplicated_topLeft) && (value?.hasOwnProperty("topLeft"))) {
+            return true
+        }
+        else if ((!duplicated_topRight) && (value?.hasOwnProperty("topRight"))) {
+            return true
+        }
+        else if ((!duplicated_bottomLeft) && (value?.hasOwnProperty("bottomLeft"))) {
+            return true
+        }
+        else if ((!duplicated_bottomRight) && (value?.hasOwnProperty("bottomRight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BorderRadiuses_graphics")
+        }
+    }
+    static isBorderStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BorderStyle.Dotted)) {
+            return true
+        }
+        else if ((value) === (BorderStyle.Dashed)) {
+            return true
+        }
+        else if ((value) === (BorderStyle.Solid)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BorderStyle")
+        }
+    }
+    static isBottomTabBarStyle(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof BottomTabBarStyle")
+    }
+    static isBounceSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_scope: boolean, duplicated_direction: boolean): boolean {
+        if ((!duplicated_scope) && (value?.hasOwnProperty("scope"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BounceSymbolEffect")
+        }
+    }
+    static isBreakPoints(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_reference: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_reference) && (value?.hasOwnProperty("reference"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BreakPoints")
+        }
+    }
+    static isBreakpointsReference(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (BreakpointsReference.WindowSize)) {
+            return true
+        }
+        else if ((value) === (BreakpointsReference.ComponentSize)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BreakpointsReference")
+        }
+    }
+    static isBuilderNodeOps(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof BuilderNodeOps")
+    }
+    static isBuilderNodeOptions(value: Object | string | number | undefined | boolean, duplicated_selfIdealSize: boolean, duplicated_type: boolean, duplicated_surfaceId: boolean): boolean {
+        if ((!duplicated_selfIdealSize) && (value?.hasOwnProperty("selfIdealSize"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_surfaceId) && (value?.hasOwnProperty("surfaceId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BuilderNodeOptions")
+        }
+    }
+    static isBusinessError(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_message: boolean, duplicated_stack: boolean, duplicated_code: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_code) && (value?.hasOwnProperty("code"))) {
+            return true
+        }
+        else if ((!duplicated_stack) && (value?.hasOwnProperty("stack"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof BusinessError")
+        }
+    }
+    static isButtonConfiguration(value: Object | string | number | undefined | boolean, duplicated_label: boolean, duplicated_pressed: boolean, duplicated_triggerClick: boolean): boolean {
+        if ((!duplicated_label) && (value?.hasOwnProperty("label"))) {
+            return true
+        }
+        else if ((!duplicated_pressed) && (value?.hasOwnProperty("pressed"))) {
+            return true
+        }
+        else if ((!duplicated_triggerClick) && (value?.hasOwnProperty("triggerClick"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonConfiguration")
+        }
+    }
+    static isButtonIconOptions(value: Object | string | number | undefined | boolean, duplicated_shown: boolean, duplicated_hidden: boolean, duplicated_switching: boolean): boolean {
+        if ((!duplicated_shown) && (value?.hasOwnProperty("shown"))) {
+            return true
+        }
+        else if ((!duplicated_hidden) && (value?.hasOwnProperty("hidden"))) {
+            return true
+        }
+        else if ((!duplicated_switching) && (value?.hasOwnProperty("switching"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonIconOptions")
+        }
+    }
+    static isButtonLabelStyle(value: Object | string | number | undefined | boolean, duplicated_overflow: boolean, duplicated_maxLines: boolean, duplicated_minFontSize: boolean, duplicated_maxFontSize: boolean, duplicated_heightAdaptivePolicy: boolean, duplicated_font: boolean): boolean {
+        if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_minFontSize) && (value?.hasOwnProperty("minFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_maxFontSize) && (value?.hasOwnProperty("maxFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_heightAdaptivePolicy) && (value?.hasOwnProperty("heightAdaptivePolicy"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonLabelStyle")
+        }
+    }
+    static isButtonOptions(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_stateEffect: boolean, duplicated_buttonStyle: boolean, duplicated_controlSize: boolean, duplicated_role: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_stateEffect) && (value?.hasOwnProperty("stateEffect"))) {
+            return true
+        }
+        else if ((!duplicated_buttonStyle) && (value?.hasOwnProperty("buttonStyle"))) {
+            return true
+        }
+        else if ((!duplicated_controlSize) && (value?.hasOwnProperty("controlSize"))) {
+            return true
+        }
+        else if ((!duplicated_role) && (value?.hasOwnProperty("role"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonOptions")
+        }
+    }
+    static isButtonRole(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ButtonRole.NORMAL)) {
+            return true
+        }
+        else if ((value) === (ButtonRole.ERROR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonRole")
+        }
+    }
+    static isButtonStyle(value: Object | string | number | undefined | boolean, duplicated_left: boolean, duplicated_top: boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_icons: boolean): boolean {
+        if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_icons) && (value?.hasOwnProperty("icons"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonStyle")
+        }
+    }
+    static isButtonStyleMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ButtonStyleMode.NORMAL)) {
+            return true
+        }
+        else if ((value) === (ButtonStyleMode.EMPHASIZED)) {
+            return true
+        }
+        else if ((value) === (ButtonStyleMode.TEXTUAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonStyleMode")
+        }
+    }
+    static isButtonType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ButtonType.Capsule)) {
+            return true
+        }
+        else if ((value) === (ButtonType.Circle)) {
+            return true
+        }
+        else if ((value) === (ButtonType.Normal)) {
+            return true
+        }
+        else if ((value) === (ButtonType.ROUNDED_RECTANGLE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ButtonType")
+        }
+    }
+    static isCacheMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CacheMode.Default)) {
+            return true
+        }
+        else if ((value) === (CacheMode.None)) {
+            return true
+        }
+        else if ((value) === (CacheMode.Online)) {
+            return true
+        }
+        else if ((value) === (CacheMode.Only)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CacheMode")
+        }
+    }
+    static isCalendarAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CalendarAlign.START)) {
+            return true
+        }
+        else if ((value) === (CalendarAlign.CENTER)) {
+            return true
+        }
+        else if ((value) === (CalendarAlign.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarAlign")
+        }
+    }
+    static isCalendarController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CalendarController")
+    }
+    static isCalendarDay(value: Object | string | number | undefined | boolean, duplicated_index: boolean, duplicated_lunarMonth: boolean, duplicated_lunarDay: boolean, duplicated_dayMark: boolean, duplicated_dayMarkValue: boolean, duplicated_year: boolean, duplicated_month: boolean, duplicated_day: boolean, duplicated_isFirstOfLunar: boolean, duplicated_hasSchedule: boolean, duplicated_markLunarDay: boolean): boolean {
+        if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_lunarMonth) && (value?.hasOwnProperty("lunarMonth"))) {
+            return true
+        }
+        else if ((!duplicated_lunarDay) && (value?.hasOwnProperty("lunarDay"))) {
+            return true
+        }
+        else if ((!duplicated_dayMark) && (value?.hasOwnProperty("dayMark"))) {
+            return true
+        }
+        else if ((!duplicated_dayMarkValue) && (value?.hasOwnProperty("dayMarkValue"))) {
+            return true
+        }
+        else if ((!duplicated_year) && (value?.hasOwnProperty("year"))) {
+            return true
+        }
+        else if ((!duplicated_month) && (value?.hasOwnProperty("month"))) {
+            return true
+        }
+        else if ((!duplicated_day) && (value?.hasOwnProperty("day"))) {
+            return true
+        }
+        else if ((!duplicated_isFirstOfLunar) && (value?.hasOwnProperty("isFirstOfLunar"))) {
+            return true
+        }
+        else if ((!duplicated_hasSchedule) && (value?.hasOwnProperty("hasSchedule"))) {
+            return true
+        }
+        else if ((!duplicated_markLunarDay) && (value?.hasOwnProperty("markLunarDay"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarDay")
+        }
+    }
+    static isCalendarDialogOptions(value: Object | string | number | undefined | boolean, duplicated_onAccept: boolean, duplicated_onCancel: boolean, duplicated_onChange: boolean, duplicated_backgroundColor: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_acceptButtonStyle: boolean, duplicated_cancelButtonStyle: boolean, duplicated_onDidAppear: boolean, duplicated_onDidDisappear: boolean, duplicated_onWillAppear: boolean, duplicated_onWillDisappear: boolean, duplicated_shadow: boolean, duplicated_enableHoverMode: boolean, duplicated_hoverModeArea: boolean, duplicated_markToday: boolean): boolean {
+        if ((!duplicated_onAccept) && (value?.hasOwnProperty("onAccept"))) {
+            return true
+        }
+        else if ((!duplicated_onCancel) && (value?.hasOwnProperty("onCancel"))) {
+            return true
+        }
+        else if ((!duplicated_onChange) && (value?.hasOwnProperty("onChange"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_acceptButtonStyle) && (value?.hasOwnProperty("acceptButtonStyle"))) {
+            return true
+        }
+        else if ((!duplicated_cancelButtonStyle) && (value?.hasOwnProperty("cancelButtonStyle"))) {
+            return true
+        }
+        else if ((!duplicated_onDidAppear) && (value?.hasOwnProperty("onDidAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDidDisappear) && (value?.hasOwnProperty("onDidDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillAppear) && (value?.hasOwnProperty("onWillAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDisappear) && (value?.hasOwnProperty("onWillDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_hoverModeArea) && (value?.hasOwnProperty("hoverModeArea"))) {
+            return true
+        }
+        else if ((!duplicated_markToday) && (value?.hasOwnProperty("markToday"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarDialogOptions")
+        }
+    }
+    static isCalendarOptions(value: Object | string | number | undefined | boolean, duplicated_hintRadius: boolean, duplicated_selected: boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_disabledDateRange: boolean): boolean {
+        if ((!duplicated_hintRadius) && (value?.hasOwnProperty("hintRadius"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_disabledDateRange) && (value?.hasOwnProperty("disabledDateRange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarOptions")
+        }
+    }
+    static isCalendarPickerDialog(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CalendarPickerDialog")
+    }
+    static isCalendarRequestedData(value: Object | string | number | undefined | boolean, duplicated_year: boolean, duplicated_month: boolean, duplicated_currentYear: boolean, duplicated_currentMonth: boolean, duplicated_monthState: boolean): boolean {
+        if ((!duplicated_year) && (value?.hasOwnProperty("year"))) {
+            return true
+        }
+        else if ((!duplicated_month) && (value?.hasOwnProperty("month"))) {
+            return true
+        }
+        else if ((!duplicated_currentYear) && (value?.hasOwnProperty("currentYear"))) {
+            return true
+        }
+        else if ((!duplicated_currentMonth) && (value?.hasOwnProperty("currentMonth"))) {
+            return true
+        }
+        else if ((!duplicated_monthState) && (value?.hasOwnProperty("monthState"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarRequestedData")
+        }
+    }
+    static isCalendarRequestedMonths(value: Object | string | number | undefined | boolean, duplicated_date: boolean, duplicated_currentData: boolean, duplicated_preData: boolean, duplicated_nextData: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_date) && (value?.hasOwnProperty("date"))) {
+            return true
+        }
+        else if ((!duplicated_currentData) && (value?.hasOwnProperty("currentData"))) {
+            return true
+        }
+        else if ((!duplicated_preData) && (value?.hasOwnProperty("preData"))) {
+            return true
+        }
+        else if ((!duplicated_nextData) && (value?.hasOwnProperty("nextData"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarRequestedMonths")
+        }
+    }
+    static isCalendarSelectedDate(value: Object | string | number | undefined | boolean, duplicated_year: boolean, duplicated_month: boolean, duplicated_day: boolean): boolean {
+        if ((!duplicated_year) && (value?.hasOwnProperty("year"))) {
+            return true
+        }
+        else if ((!duplicated_month) && (value?.hasOwnProperty("month"))) {
+            return true
+        }
+        else if ((!duplicated_day) && (value?.hasOwnProperty("day"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CalendarSelectedDate")
+        }
+    }
+    static isCancelButtonOptions(value: Object | string | number | undefined | boolean, duplicated_style: boolean, duplicated_icon: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CancelButtonOptions")
+        }
+    }
+    static isCancelButtonStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CancelButtonStyle.CONSTANT)) {
+            return true
+        }
+        else if ((value) === (CancelButtonStyle.INVISIBLE)) {
+            return true
+        }
+        else if ((value) === (CancelButtonStyle.INPUT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CancelButtonStyle")
+        }
+    }
+    static isCancelButtonSymbolOptions(value: Object | string | number | undefined | boolean, duplicated_style: boolean, duplicated_icon: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CancelButtonSymbolOptions")
+        }
+    }
+    static isCanvasGradient(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CanvasGradient")
+    }
+    static isCanvasPath(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CanvasPath")
+    }
+    static isCanvasPattern(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CanvasPattern")
+    }
+    static isCanvasRenderer(value: Object | string | number | undefined | boolean, duplicated_letterSpacing: boolean, duplicated_globalAlpha: boolean, duplicated_globalCompositeOperation: boolean, duplicated_fillStyle: boolean, duplicated_strokeStyle: boolean, duplicated_filter: boolean, duplicated_imageSmoothingEnabled: boolean, duplicated_imageSmoothingQuality: boolean, duplicated_lineCap: boolean, duplicated_lineDashOffset: boolean, duplicated_lineJoin: boolean, duplicated_lineWidth: boolean, duplicated_miterLimit: boolean, duplicated_shadowBlur: boolean, duplicated_shadowColor: boolean, duplicated_shadowOffsetX: boolean, duplicated_shadowOffsetY: boolean, duplicated_direction: boolean, duplicated_font: boolean, duplicated_textAlign: boolean, duplicated_textBaseline: boolean): boolean {
+        if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_globalAlpha) && (value?.hasOwnProperty("globalAlpha"))) {
+            return true
+        }
+        else if ((!duplicated_globalCompositeOperation) && (value?.hasOwnProperty("globalCompositeOperation"))) {
+            return true
+        }
+        else if ((!duplicated_fillStyle) && (value?.hasOwnProperty("fillStyle"))) {
+            return true
+        }
+        else if ((!duplicated_strokeStyle) && (value?.hasOwnProperty("strokeStyle"))) {
+            return true
+        }
+        else if ((!duplicated_filter) && (value?.hasOwnProperty("filter"))) {
+            return true
+        }
+        else if ((!duplicated_imageSmoothingEnabled) && (value?.hasOwnProperty("imageSmoothingEnabled"))) {
+            return true
+        }
+        else if ((!duplicated_imageSmoothingQuality) && (value?.hasOwnProperty("imageSmoothingQuality"))) {
+            return true
+        }
+        else if ((!duplicated_lineCap) && (value?.hasOwnProperty("lineCap"))) {
+            return true
+        }
+        else if ((!duplicated_lineDashOffset) && (value?.hasOwnProperty("lineDashOffset"))) {
+            return true
+        }
+        else if ((!duplicated_lineJoin) && (value?.hasOwnProperty("lineJoin"))) {
+            return true
+        }
+        else if ((!duplicated_lineWidth) && (value?.hasOwnProperty("lineWidth"))) {
+            return true
+        }
+        else if ((!duplicated_miterLimit) && (value?.hasOwnProperty("miterLimit"))) {
+            return true
+        }
+        else if ((!duplicated_shadowBlur) && (value?.hasOwnProperty("shadowBlur"))) {
+            return true
+        }
+        else if ((!duplicated_shadowColor) && (value?.hasOwnProperty("shadowColor"))) {
+            return true
+        }
+        else if ((!duplicated_shadowOffsetX) && (value?.hasOwnProperty("shadowOffsetX"))) {
+            return true
+        }
+        else if ((!duplicated_shadowOffsetY) && (value?.hasOwnProperty("shadowOffsetY"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else if ((!duplicated_textAlign) && (value?.hasOwnProperty("textAlign"))) {
+            return true
+        }
+        else if ((!duplicated_textBaseline) && (value?.hasOwnProperty("textBaseline"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CanvasRenderer")
+        }
+    }
+    static isCanvasRenderingContext2D(value: Object | string | number | undefined | boolean, duplicated_height: boolean, duplicated_width: boolean, duplicated_canvas: boolean): boolean {
+        if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_canvas) && (value?.hasOwnProperty("canvas"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CanvasRenderingContext2D")
+        }
+    }
+    static isCapsuleStyleOptions(value: Object | string | number | undefined | boolean, duplicated_borderColor: boolean, duplicated_borderWidth: boolean, duplicated_font: boolean, duplicated_fontColor: boolean, duplicated_showDefaultPercentage: boolean, duplicated_borderRadius: boolean): boolean {
+        if ((!duplicated_borderColor) && (value?.hasOwnProperty("borderColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_showDefaultPercentage) && (value?.hasOwnProperty("showDefaultPercentage"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CapsuleStyleOptions")
+        }
+    }
+    static isCaretOffset(value: Object | string | number | undefined | boolean, duplicated_index: boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CaretOffset")
+        }
+    }
+    static isCaretStyle(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_color: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CaretStyle")
+        }
+    }
+    static isChainAnimationOptions(value: Object | string | number | undefined | boolean, duplicated_minSpace: boolean, duplicated_maxSpace: boolean, duplicated_conductivity: boolean, duplicated_intensity: boolean, duplicated_edgeEffect: boolean, duplicated_stiffness: boolean, duplicated_damping: boolean): boolean {
+        if ((!duplicated_minSpace) && (value?.hasOwnProperty("minSpace"))) {
+            return true
+        }
+        else if ((!duplicated_maxSpace) && (value?.hasOwnProperty("maxSpace"))) {
+            return true
+        }
+        else if ((!duplicated_conductivity) && (value?.hasOwnProperty("conductivity"))) {
+            return true
+        }
+        else if ((!duplicated_intensity) && (value?.hasOwnProperty("intensity"))) {
+            return true
+        }
+        else if ((!duplicated_edgeEffect) && (value?.hasOwnProperty("edgeEffect"))) {
+            return true
+        }
+        else if ((!duplicated_stiffness) && (value?.hasOwnProperty("stiffness"))) {
+            return true
+        }
+        else if ((!duplicated_damping) && (value?.hasOwnProperty("damping"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ChainAnimationOptions")
+        }
+    }
+    static isChainEdgeEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ChainEdgeEffect.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (ChainEdgeEffect.STRETCH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ChainEdgeEffect")
+        }
+    }
+    static isChainStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ChainStyle.SPREAD)) {
+            return true
+        }
+        else if ((value) === (ChainStyle.SPREAD_INSIDE)) {
+            return true
+        }
+        else if ((value) === (ChainStyle.PACKED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ChainStyle")
+        }
+    }
+    static isChainWeightOptions(value: Object | string | number | undefined | boolean, duplicated_horizontal: boolean, duplicated_vertical: boolean): boolean {
+        if ((!duplicated_horizontal) && (value?.hasOwnProperty("horizontal"))) {
+            return true
+        }
+        else if ((!duplicated_vertical) && (value?.hasOwnProperty("vertical"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ChainWeightOptions")
+        }
+    }
+    static isCheckBoxConfiguration(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_selected: boolean, duplicated_triggerChange: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_triggerChange) && (value?.hasOwnProperty("triggerChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CheckBoxConfiguration")
+        }
+    }
+    static isCheckboxGroupOptions(value: Object | string | number | undefined | boolean, duplicated_group: boolean): boolean {
+        if ((!duplicated_group) && (value?.hasOwnProperty("group"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CheckboxGroupOptions")
+        }
+    }
+    static isCheckboxGroupResult(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_status: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_status) && (value?.hasOwnProperty("status"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CheckboxGroupResult")
+        }
+    }
+    static isCheckboxOptions(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_group: boolean, duplicated_indicatorBuilder: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_group) && (value?.hasOwnProperty("group"))) {
+            return true
+        }
+        else if ((!duplicated_indicatorBuilder) && (value?.hasOwnProperty("indicatorBuilder"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CheckboxOptions")
+        }
+    }
+    static isCheckBoxShape(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CheckBoxShape.CIRCLE)) {
+            return true
+        }
+        else if ((value) === (CheckBoxShape.ROUNDED_SQUARE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CheckBoxShape")
+        }
+    }
+    static isChildrenMainSize(value: Object | string | number | undefined | boolean, duplicated_childDefaultSize: boolean): boolean {
+        if ((!duplicated_childDefaultSize) && (value?.hasOwnProperty("childDefaultSize"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ChildrenMainSize")
+        }
+    }
+    static isCircle(value: Object | string | number | undefined | boolean, duplicated_centerX: boolean, duplicated_centerY: boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_centerX) && (value?.hasOwnProperty("centerX"))) {
+            return true
+        }
+        else if ((!duplicated_centerY) && (value?.hasOwnProperty("centerY"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Circle")
+        }
+    }
+    static isCircleOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CircleOptions")
+    }
+    static isCircleShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CircleShape")
+    }
+    static isCircleStyleOptions(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_radius: boolean, duplicated_enableWaveEffect: boolean, duplicated_enableForeground: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_enableWaveEffect) && (value?.hasOwnProperty("enableWaveEffect"))) {
+            return true
+        }
+        else if ((!duplicated_enableForeground) && (value?.hasOwnProperty("enableForeground"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CircleStyleOptions")
+        }
+    }
+    static isClickEffect(value: Object | string | number | undefined | boolean, duplicated_level: boolean, duplicated_scale: boolean): boolean {
+        if ((!duplicated_level) && (value?.hasOwnProperty("level"))) {
+            return true
+        }
+        else if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ClickEffect")
+        }
+    }
+    static isClickEffectLevel(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ClickEffectLevel.LIGHT)) {
+            return true
+        }
+        else if ((value) === (ClickEffectLevel.MIDDLE)) {
+            return true
+        }
+        else if ((value) === (ClickEffectLevel.HEAVY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ClickEffectLevel")
+        }
+    }
+    static isClickEvent(value: Object | string | number | undefined | boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_hand: boolean, duplicated_preventDefault: boolean): boolean {
+        if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_preventDefault) && (value?.hasOwnProperty("preventDefault"))) {
+            return true
+        }
+        else if ((!duplicated_hand) && (value?.hasOwnProperty("hand"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ClickEvent")
+        }
+    }
+    static isClientAuthenticationHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ClientAuthenticationHandler")
+    }
+    static isCloseSwipeActionOptions(value: Object | string | number | undefined | boolean, duplicated_onFinish: boolean): boolean {
+        if ((!duplicated_onFinish) && (value?.hasOwnProperty("onFinish"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CloseSwipeActionOptions")
+        }
+    }
+    static isColor(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Color.White)) {
+            return true
+        }
+        else if ((value) === (Color.Black)) {
+            return true
+        }
+        else if ((value) === (Color.Blue)) {
+            return true
+        }
+        else if ((value) === (Color.Brown)) {
+            return true
+        }
+        else if ((value) === (Color.Gray)) {
+            return true
+        }
+        else if ((value) === (Color.Green)) {
+            return true
+        }
+        else if ((value) === (Color.Grey)) {
+            return true
+        }
+        else if ((value) === (Color.Orange)) {
+            return true
+        }
+        else if ((value) === (Color.Pink)) {
+            return true
+        }
+        else if ((value) === (Color.Red)) {
+            return true
+        }
+        else if ((value) === (Color.Yellow)) {
+            return true
+        }
+        else if ((value) === (Color.Transparent)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Color")
+        }
+    }
+    static isColorContent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ColorContent")
+    }
+    static isColorFilter(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ColorFilter")
+    }
+    static isColoringStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ColoringStrategy.INVERT)) {
+            return true
+        }
+        else if ((value) === (ColoringStrategy.AVERAGE)) {
+            return true
+        }
+        else if ((value) === (ColoringStrategy.PRIMARY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColoringStrategy")
+        }
+    }
+    static isColorMetrics(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ColorMetrics")
+    }
+    static isColorMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ColorMode.LIGHT)) {
+            return true
+        }
+        else if ((value) === (ColorMode.DARK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColorMode")
+        }
+    }
+    static isColors(value: Object | string | number | undefined | boolean, duplicated_brand: boolean, duplicated_warning: boolean, duplicated_alert: boolean, duplicated_confirm: boolean, duplicated_fontPrimary: boolean, duplicated_fontSecondary: boolean, duplicated_fontTertiary: boolean, duplicated_fontFourth: boolean, duplicated_fontEmphasize: boolean, duplicated_fontOnPrimary: boolean, duplicated_fontOnSecondary: boolean, duplicated_fontOnTertiary: boolean, duplicated_fontOnFourth: boolean, duplicated_iconPrimary: boolean, duplicated_iconSecondary: boolean, duplicated_iconTertiary: boolean, duplicated_iconFourth: boolean, duplicated_iconEmphasize: boolean, duplicated_iconSubEmphasize: boolean, duplicated_iconOnPrimary: boolean, duplicated_iconOnSecondary: boolean, duplicated_iconOnTertiary: boolean, duplicated_iconOnFourth: boolean, duplicated_backgroundPrimary: boolean, duplicated_backgroundSecondary: boolean, duplicated_backgroundTertiary: boolean, duplicated_backgroundFourth: boolean, duplicated_backgroundEmphasize: boolean, duplicated_compForegroundPrimary: boolean, duplicated_compBackgroundPrimary: boolean, duplicated_compBackgroundPrimaryTran: boolean, duplicated_compBackgroundPrimaryContrary: boolean, duplicated_compBackgroundGray: boolean, duplicated_compBackgroundSecondary: boolean, duplicated_compBackgroundTertiary: boolean, duplicated_compBackgroundEmphasize: boolean, duplicated_compBackgroundNeutral: boolean, duplicated_compEmphasizeSecondary: boolean, duplicated_compEmphasizeTertiary: boolean, duplicated_compDivider: boolean, duplicated_compCommonContrary: boolean, duplicated_compBackgroundFocus: boolean, duplicated_compFocusedPrimary: boolean, duplicated_compFocusedSecondary: boolean, duplicated_compFocusedTertiary: boolean, duplicated_interactiveHover: boolean, duplicated_interactivePressed: boolean, duplicated_interactiveFocus: boolean, duplicated_interactiveActive: boolean, duplicated_interactiveSelect: boolean, duplicated_interactiveClick: boolean): boolean {
+        if ((!duplicated_brand) && (value?.hasOwnProperty("brand"))) {
+            return true
+        }
+        else if ((!duplicated_warning) && (value?.hasOwnProperty("warning"))) {
+            return true
+        }
+        else if ((!duplicated_alert) && (value?.hasOwnProperty("alert"))) {
+            return true
+        }
+        else if ((!duplicated_confirm) && (value?.hasOwnProperty("confirm"))) {
+            return true
+        }
+        else if ((!duplicated_fontPrimary) && (value?.hasOwnProperty("fontPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_fontSecondary) && (value?.hasOwnProperty("fontSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_fontTertiary) && (value?.hasOwnProperty("fontTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_fontFourth) && (value?.hasOwnProperty("fontFourth"))) {
+            return true
+        }
+        else if ((!duplicated_fontEmphasize) && (value?.hasOwnProperty("fontEmphasize"))) {
+            return true
+        }
+        else if ((!duplicated_fontOnPrimary) && (value?.hasOwnProperty("fontOnPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_fontOnSecondary) && (value?.hasOwnProperty("fontOnSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_fontOnTertiary) && (value?.hasOwnProperty("fontOnTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_fontOnFourth) && (value?.hasOwnProperty("fontOnFourth"))) {
+            return true
+        }
+        else if ((!duplicated_iconPrimary) && (value?.hasOwnProperty("iconPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_iconSecondary) && (value?.hasOwnProperty("iconSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_iconTertiary) && (value?.hasOwnProperty("iconTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_iconFourth) && (value?.hasOwnProperty("iconFourth"))) {
+            return true
+        }
+        else if ((!duplicated_iconEmphasize) && (value?.hasOwnProperty("iconEmphasize"))) {
+            return true
+        }
+        else if ((!duplicated_iconSubEmphasize) && (value?.hasOwnProperty("iconSubEmphasize"))) {
+            return true
+        }
+        else if ((!duplicated_iconOnPrimary) && (value?.hasOwnProperty("iconOnPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_iconOnSecondary) && (value?.hasOwnProperty("iconOnSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_iconOnTertiary) && (value?.hasOwnProperty("iconOnTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_iconOnFourth) && (value?.hasOwnProperty("iconOnFourth"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundPrimary) && (value?.hasOwnProperty("backgroundPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundSecondary) && (value?.hasOwnProperty("backgroundSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundTertiary) && (value?.hasOwnProperty("backgroundTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundFourth) && (value?.hasOwnProperty("backgroundFourth"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEmphasize) && (value?.hasOwnProperty("backgroundEmphasize"))) {
+            return true
+        }
+        else if ((!duplicated_compForegroundPrimary) && (value?.hasOwnProperty("compForegroundPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundPrimary) && (value?.hasOwnProperty("compBackgroundPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundPrimaryTran) && (value?.hasOwnProperty("compBackgroundPrimaryTran"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundPrimaryContrary) && (value?.hasOwnProperty("compBackgroundPrimaryContrary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundGray) && (value?.hasOwnProperty("compBackgroundGray"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundSecondary) && (value?.hasOwnProperty("compBackgroundSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundTertiary) && (value?.hasOwnProperty("compBackgroundTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundEmphasize) && (value?.hasOwnProperty("compBackgroundEmphasize"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundNeutral) && (value?.hasOwnProperty("compBackgroundNeutral"))) {
+            return true
+        }
+        else if ((!duplicated_compEmphasizeSecondary) && (value?.hasOwnProperty("compEmphasizeSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_compEmphasizeTertiary) && (value?.hasOwnProperty("compEmphasizeTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_compDivider) && (value?.hasOwnProperty("compDivider"))) {
+            return true
+        }
+        else if ((!duplicated_compCommonContrary) && (value?.hasOwnProperty("compCommonContrary"))) {
+            return true
+        }
+        else if ((!duplicated_compBackgroundFocus) && (value?.hasOwnProperty("compBackgroundFocus"))) {
+            return true
+        }
+        else if ((!duplicated_compFocusedPrimary) && (value?.hasOwnProperty("compFocusedPrimary"))) {
+            return true
+        }
+        else if ((!duplicated_compFocusedSecondary) && (value?.hasOwnProperty("compFocusedSecondary"))) {
+            return true
+        }
+        else if ((!duplicated_compFocusedTertiary) && (value?.hasOwnProperty("compFocusedTertiary"))) {
+            return true
+        }
+        else if ((!duplicated_interactiveHover) && (value?.hasOwnProperty("interactiveHover"))) {
+            return true
+        }
+        else if ((!duplicated_interactivePressed) && (value?.hasOwnProperty("interactivePressed"))) {
+            return true
+        }
+        else if ((!duplicated_interactiveFocus) && (value?.hasOwnProperty("interactiveFocus"))) {
+            return true
+        }
+        else if ((!duplicated_interactiveActive) && (value?.hasOwnProperty("interactiveActive"))) {
+            return true
+        }
+        else if ((!duplicated_interactiveSelect) && (value?.hasOwnProperty("interactiveSelect"))) {
+            return true
+        }
+        else if ((!duplicated_interactiveClick) && (value?.hasOwnProperty("interactiveClick"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Colors")
+        }
+    }
+    static isColorStop(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_offset: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColorStop")
+        }
+    }
+    static isColumnOptions(value: Object | string | number | undefined | boolean, duplicated_space: boolean): boolean {
+        if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColumnOptions")
+        }
+    }
+    static isColumnOptionsV2(value: Object | string | number | undefined | boolean, duplicated__stub: boolean): boolean {
+        if ((!duplicated__stub) && (value?.hasOwnProperty("_stub"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColumnOptionsV2")
+        }
+    }
+    static isColumnSplitDividerStyle(value: Object | string | number | undefined | boolean, duplicated_startMargin: boolean, duplicated_endMargin: boolean): boolean {
+        if ((!duplicated_startMargin) && (value?.hasOwnProperty("startMargin"))) {
+            return true
+        }
+        else if ((!duplicated_endMargin) && (value?.hasOwnProperty("endMargin"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ColumnSplitDividerStyle")
+        }
+    }
+    static isCommandPath(value: Object | string | number | undefined | boolean, duplicated_commands: boolean): boolean {
+        if ((!duplicated_commands) && (value?.hasOwnProperty("commands"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CommandPath")
+        }
+    }
+    static iscommon_Context(value: Object | string | number | undefined | boolean, duplicated_cacheDir: boolean, duplicated_tempDir: boolean, duplicated_filesDir: boolean, duplicated_databaseDir: boolean, duplicated_preferencesDir: boolean, duplicated_bundleCodeDir: boolean, duplicated_distributedFilesDir: boolean, duplicated_resourceDir: boolean, duplicated_cloudFileDir: boolean): boolean {
+        if ((!duplicated_cacheDir) && (value?.hasOwnProperty("cacheDir"))) {
+            return true
+        }
+        else if ((!duplicated_tempDir) && (value?.hasOwnProperty("tempDir"))) {
+            return true
+        }
+        else if ((!duplicated_filesDir) && (value?.hasOwnProperty("filesDir"))) {
+            return true
+        }
+        else if ((!duplicated_databaseDir) && (value?.hasOwnProperty("databaseDir"))) {
+            return true
+        }
+        else if ((!duplicated_preferencesDir) && (value?.hasOwnProperty("preferencesDir"))) {
+            return true
+        }
+        else if ((!duplicated_bundleCodeDir) && (value?.hasOwnProperty("bundleCodeDir"))) {
+            return true
+        }
+        else if ((!duplicated_distributedFilesDir) && (value?.hasOwnProperty("distributedFilesDir"))) {
+            return true
+        }
+        else if ((!duplicated_resourceDir) && (value?.hasOwnProperty("resourceDir"))) {
+            return true
+        }
+        else if ((!duplicated_cloudFileDir) && (value?.hasOwnProperty("cloudFileDir"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof common.Context")
+        }
+    }
+    static iscommon2D_Color(value: Object | string | number | undefined | boolean, duplicated_alpha: boolean, duplicated_red: boolean, duplicated_green: boolean, duplicated_blue: boolean): boolean {
+        if ((!duplicated_alpha) && (value?.hasOwnProperty("alpha"))) {
+            return true
+        }
+        else if ((!duplicated_red) && (value?.hasOwnProperty("red"))) {
+            return true
+        }
+        else if ((!duplicated_green) && (value?.hasOwnProperty("green"))) {
+            return true
+        }
+        else if ((!duplicated_blue) && (value?.hasOwnProperty("blue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof common2D.Color")
+        }
+    }
+    static iscommon2D_Point(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof common2D.Point")
+        }
+    }
+    static iscommon2D_Point3d(value: Object | string | number | undefined | boolean, duplicated_z: boolean): boolean {
+        if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof common2D.Point3d")
+        }
+    }
+    static iscommon2D_Rect(value: Object | string | number | undefined | boolean, duplicated_left: boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean): boolean {
+        if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof common2D.Rect")
+        }
+    }
+    static isCommonShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CommonShape")
+    }
+    static isCompatibleComponentInfo(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_component: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_component) && (value?.hasOwnProperty("component"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CompatibleComponentInfo")
+        }
+    }
+    static isComponentContent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ComponentContent")
+    }
+    static isComponentInfo(value: Object | string | number | undefined | boolean, duplicated_size: boolean, duplicated_localOffset: boolean, duplicated_windowOffset: boolean, duplicated_screenOffset: boolean, duplicated_translate: boolean, duplicated_scale: boolean, duplicated_rotate: boolean, duplicated_transform: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_localOffset) && (value?.hasOwnProperty("localOffset"))) {
+            return true
+        }
+        else if ((!duplicated_windowOffset) && (value?.hasOwnProperty("windowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_screenOffset) && (value?.hasOwnProperty("screenOffset"))) {
+            return true
+        }
+        else if ((!duplicated_translate) && (value?.hasOwnProperty("translate"))) {
+            return true
+        }
+        else if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_rotate) && (value?.hasOwnProperty("rotate"))) {
+            return true
+        }
+        else if ((!duplicated_transform) && (value?.hasOwnProperty("transform"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ComponentInfo")
+        }
+    }
+    static isComputedBarAttribute(value: Object | string | number | undefined | boolean, duplicated_totalOffset: boolean, duplicated_totalLength: boolean): boolean {
+        if ((!duplicated_totalOffset) && (value?.hasOwnProperty("totalOffset"))) {
+            return true
+        }
+        else if ((!duplicated_totalLength) && (value?.hasOwnProperty("totalLength"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ComputedBarAttribute")
+        }
+    }
+    static isConsoleMessage(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ConsoleMessage")
+    }
+    static isConstraintSizeOptions(value: Object | string | number | undefined | boolean, duplicated_minWidth: boolean, duplicated_maxWidth: boolean, duplicated_minHeight: boolean, duplicated_maxHeight: boolean): boolean {
+        if ((!duplicated_minWidth) && (value?.hasOwnProperty("minWidth"))) {
+            return true
+        }
+        else if ((!duplicated_maxWidth) && (value?.hasOwnProperty("maxWidth"))) {
+            return true
+        }
+        else if ((!duplicated_minHeight) && (value?.hasOwnProperty("minHeight"))) {
+            return true
+        }
+        else if ((!duplicated_maxHeight) && (value?.hasOwnProperty("maxHeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ConstraintSizeOptions")
+        }
+    }
+    static isContentClipMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContentClipMode.CONTENT_ONLY)) {
+            return true
+        }
+        else if ((value) === (ContentClipMode.BOUNDARY)) {
+            return true
+        }
+        else if ((value) === (ContentClipMode.SAFE_AREA)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContentClipMode")
+        }
+    }
+    static isContentCoverOptions(value: Object | string | number | undefined | boolean, duplicated_modalTransition: boolean, duplicated_onWillDismiss: boolean, duplicated_transition: boolean): boolean {
+        if ((!duplicated_modalTransition) && (value?.hasOwnProperty("modalTransition"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContentCoverOptions")
+        }
+    }
+    static isContentModifier(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ContentModifier")
+    }
+    static isContentType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContentType.USER_NAME)) {
+            return true
+        }
+        else if ((value) === (ContentType.PASSWORD)) {
+            return true
+        }
+        else if ((value) === (ContentType.NEW_PASSWORD)) {
+            return true
+        }
+        else if ((value) === (ContentType.FULL_STREET_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.HOUSE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.DISTRICT_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.CITY_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.PROVINCE_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.COUNTRY_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.PERSON_FULL_NAME)) {
+            return true
+        }
+        else if ((value) === (ContentType.PERSON_LAST_NAME)) {
+            return true
+        }
+        else if ((value) === (ContentType.PERSON_FIRST_NAME)) {
+            return true
+        }
+        else if ((value) === (ContentType.PHONE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.PHONE_COUNTRY_CODE)) {
+            return true
+        }
+        else if ((value) === (ContentType.FULL_PHONE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.EMAIL_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.BANK_CARD_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.ID_CARD_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.NICKNAME)) {
+            return true
+        }
+        else if ((value) === (ContentType.DETAIL_INFO_WITHOUT_STREET)) {
+            return true
+        }
+        else if ((value) === (ContentType.FORMAT_ADDRESS)) {
+            return true
+        }
+        else if ((value) === (ContentType.PASSPORT_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.VALIDITY)) {
+            return true
+        }
+        else if ((value) === (ContentType.ISSUE_AT)) {
+            return true
+        }
+        else if ((value) === (ContentType.ORGANIZATION)) {
+            return true
+        }
+        else if ((value) === (ContentType.TAX_ID)) {
+            return true
+        }
+        else if ((value) === (ContentType.ADDRESS_CITY_AND_STATE)) {
+            return true
+        }
+        else if ((value) === (ContentType.FLIGHT_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.LICENSE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.LICENSE_FILE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.LICENSE_PLATE)) {
+            return true
+        }
+        else if ((value) === (ContentType.ENGINE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (ContentType.LICENSE_CHASSIS_NUMBER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContentType")
+        }
+    }
+    static isContext(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof Context")
+    }
+    static isContextMenuAnimationOptions(value: Object | string | number | undefined | boolean, duplicated_scale: boolean, duplicated_transition: boolean, duplicated_hoverScale: boolean): boolean {
+        if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_hoverScale) && (value?.hasOwnProperty("hoverScale"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuAnimationOptions")
+        }
+    }
+    static isContextMenuEditStateFlags(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContextMenuEditStateFlags.NONE)) {
+            return true
+        }
+        else if ((value) === (ContextMenuEditStateFlags.CAN_CUT)) {
+            return true
+        }
+        else if ((value) === (ContextMenuEditStateFlags.CAN_COPY)) {
+            return true
+        }
+        else if ((value) === (ContextMenuEditStateFlags.CAN_PASTE)) {
+            return true
+        }
+        else if ((value) === (ContextMenuEditStateFlags.CAN_SELECT_ALL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuEditStateFlags")
+        }
+    }
+    static isContextMenuInputFieldType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContextMenuInputFieldType.None)) {
+            return true
+        }
+        else if ((value) === (ContextMenuInputFieldType.PlainText)) {
+            return true
+        }
+        else if ((value) === (ContextMenuInputFieldType.Password)) {
+            return true
+        }
+        else if ((value) === (ContextMenuInputFieldType.Number)) {
+            return true
+        }
+        else if ((value) === (ContextMenuInputFieldType.Telephone)) {
+            return true
+        }
+        else if ((value) === (ContextMenuInputFieldType.Other)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuInputFieldType")
+        }
+    }
+    static isContextMenuMediaType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContextMenuMediaType.None)) {
+            return true
+        }
+        else if ((value) === (ContextMenuMediaType.Image)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuMediaType")
+        }
+    }
+    static isContextMenuOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_placement: boolean, duplicated_enableArrow: boolean, duplicated_arrowOffset: boolean, duplicated_preview: boolean, duplicated_previewBorderRadius: boolean, duplicated_borderRadius: boolean, duplicated_onAppear: boolean, duplicated_onDisappear: boolean, duplicated_aboutToAppear: boolean, duplicated_aboutToDisappear: boolean, duplicated_layoutRegionMargin: boolean, duplicated_previewAnimationOptions: boolean, duplicated_backgroundColor: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_transition: boolean, duplicated_enableHoverMode: boolean, duplicated_outlineColor: boolean, duplicated_outlineWidth: boolean, duplicated_hapticFeedbackMode: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_placement) && (value?.hasOwnProperty("placement"))) {
+            return true
+        }
+        else if ((!duplicated_enableArrow) && (value?.hasOwnProperty("enableArrow"))) {
+            return true
+        }
+        else if ((!duplicated_arrowOffset) && (value?.hasOwnProperty("arrowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_preview) && (value?.hasOwnProperty("preview"))) {
+            return true
+        }
+        else if ((!duplicated_previewBorderRadius) && (value?.hasOwnProperty("previewBorderRadius"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else if ((!duplicated_onAppear) && (value?.hasOwnProperty("onAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDisappear) && (value?.hasOwnProperty("onDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_aboutToAppear) && (value?.hasOwnProperty("aboutToAppear"))) {
+            return true
+        }
+        else if ((!duplicated_aboutToDisappear) && (value?.hasOwnProperty("aboutToDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_layoutRegionMargin) && (value?.hasOwnProperty("layoutRegionMargin"))) {
+            return true
+        }
+        else if ((!duplicated_previewAnimationOptions) && (value?.hasOwnProperty("previewAnimationOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_outlineColor) && (value?.hasOwnProperty("outlineColor"))) {
+            return true
+        }
+        else if ((!duplicated_outlineWidth) && (value?.hasOwnProperty("outlineWidth"))) {
+            return true
+        }
+        else if ((!duplicated_hapticFeedbackMode) && (value?.hasOwnProperty("hapticFeedbackMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuOptions")
+        }
+    }
+    static isContextMenuSourceType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ContextMenuSourceType.None)) {
+            return true
+        }
+        else if ((value) === (ContextMenuSourceType.Mouse)) {
+            return true
+        }
+        else if ((value) === (ContextMenuSourceType.LongPress)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ContextMenuSourceType")
+        }
+    }
+    static isControllerHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ControllerHandler")
+    }
+    static isControlSize(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ControlSize.SMALL)) {
+            return true
+        }
+        else if ((value) === (ControlSize.NORMAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ControlSize")
+        }
+    }
+    static isCopyEvent(value: Object | string | number | undefined | boolean, duplicated_preventDefault: boolean): boolean {
+        if ((!duplicated_preventDefault) && (value?.hasOwnProperty("preventDefault"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CopyEvent")
+        }
+    }
+    static isCopyOptions(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CopyOptions.None)) {
+            return true
+        }
+        else if ((value) === (CopyOptions.InApp)) {
+            return true
+        }
+        else if ((value) === (CopyOptions.LocalDevice)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CopyOptions")
+        }
+    }
+    static isCornerRadius(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CornerRadius")
+    }
+    static isCrossLanguageOptions(value: Object | string | number | undefined | boolean, duplicated_attributeSetting: boolean): boolean {
+        if ((!duplicated_attributeSetting) && (value?.hasOwnProperty("attributeSetting"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CrossLanguageOptions")
+        }
+    }
+    static isCrownAction(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CrownAction.BEGIN)) {
+            return true
+        }
+        else if ((value) === (CrownAction.UPDATE)) {
+            return true
+        }
+        else if ((value) === (CrownAction.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CrownAction")
+        }
+    }
+    static isCrownEvent(value: Object | string | number | undefined | boolean, duplicated_timestamp: boolean, duplicated_angularVelocity: boolean, duplicated_degree: boolean, duplicated_action: boolean, duplicated_stopPropagation: boolean): boolean {
+        if ((!duplicated_timestamp) && (value?.hasOwnProperty("timestamp"))) {
+            return true
+        }
+        else if ((!duplicated_angularVelocity) && (value?.hasOwnProperty("angularVelocity"))) {
+            return true
+        }
+        else if ((!duplicated_degree) && (value?.hasOwnProperty("degree"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CrownEvent")
+        }
+    }
+    static isCrownSensitivity(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (CrownSensitivity.LOW)) {
+            return true
+        }
+        else if ((value) === (CrownSensitivity.MEDIUM)) {
+            return true
+        }
+        else if ((value) === (CrownSensitivity.HIGH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CrownSensitivity")
+        }
+    }
+    static isCurrentDayStyle(value: Object | string | number | undefined | boolean, duplicated_dayColor: boolean, duplicated_lunarColor: boolean, duplicated_markLunarColor: boolean, duplicated_dayFontSize: boolean, duplicated_lunarDayFontSize: boolean, duplicated_dayHeight: boolean, duplicated_dayWidth: boolean, duplicated_gregorianCalendarHeight: boolean, duplicated_dayYAxisOffset: boolean, duplicated_lunarDayYAxisOffset: boolean, duplicated_underscoreXAxisOffset: boolean, duplicated_underscoreYAxisOffset: boolean, duplicated_scheduleMarkerXAxisOffset: boolean, duplicated_scheduleMarkerYAxisOffset: boolean, duplicated_colSpace: boolean, duplicated_dailyFiveRowSpace: boolean, duplicated_dailySixRowSpace: boolean, duplicated_lunarHeight: boolean, duplicated_underscoreWidth: boolean, duplicated_underscoreLength: boolean, duplicated_scheduleMarkerRadius: boolean, duplicated_boundaryRowOffset: boolean, duplicated_boundaryColOffset: boolean): boolean {
+        if ((!duplicated_dayColor) && (value?.hasOwnProperty("dayColor"))) {
+            return true
+        }
+        else if ((!duplicated_lunarColor) && (value?.hasOwnProperty("lunarColor"))) {
+            return true
+        }
+        else if ((!duplicated_markLunarColor) && (value?.hasOwnProperty("markLunarColor"))) {
+            return true
+        }
+        else if ((!duplicated_dayFontSize) && (value?.hasOwnProperty("dayFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_lunarDayFontSize) && (value?.hasOwnProperty("lunarDayFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_dayHeight) && (value?.hasOwnProperty("dayHeight"))) {
+            return true
+        }
+        else if ((!duplicated_dayWidth) && (value?.hasOwnProperty("dayWidth"))) {
+            return true
+        }
+        else if ((!duplicated_gregorianCalendarHeight) && (value?.hasOwnProperty("gregorianCalendarHeight"))) {
+            return true
+        }
+        else if ((!duplicated_dayYAxisOffset) && (value?.hasOwnProperty("dayYAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_lunarDayYAxisOffset) && (value?.hasOwnProperty("lunarDayYAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_underscoreXAxisOffset) && (value?.hasOwnProperty("underscoreXAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_underscoreYAxisOffset) && (value?.hasOwnProperty("underscoreYAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_scheduleMarkerXAxisOffset) && (value?.hasOwnProperty("scheduleMarkerXAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_scheduleMarkerYAxisOffset) && (value?.hasOwnProperty("scheduleMarkerYAxisOffset"))) {
+            return true
+        }
+        else if ((!duplicated_colSpace) && (value?.hasOwnProperty("colSpace"))) {
+            return true
+        }
+        else if ((!duplicated_dailyFiveRowSpace) && (value?.hasOwnProperty("dailyFiveRowSpace"))) {
+            return true
+        }
+        else if ((!duplicated_dailySixRowSpace) && (value?.hasOwnProperty("dailySixRowSpace"))) {
+            return true
+        }
+        else if ((!duplicated_lunarHeight) && (value?.hasOwnProperty("lunarHeight"))) {
+            return true
+        }
+        else if ((!duplicated_underscoreWidth) && (value?.hasOwnProperty("underscoreWidth"))) {
+            return true
+        }
+        else if ((!duplicated_underscoreLength) && (value?.hasOwnProperty("underscoreLength"))) {
+            return true
+        }
+        else if ((!duplicated_scheduleMarkerRadius) && (value?.hasOwnProperty("scheduleMarkerRadius"))) {
+            return true
+        }
+        else if ((!duplicated_boundaryRowOffset) && (value?.hasOwnProperty("boundaryRowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_boundaryColOffset) && (value?.hasOwnProperty("boundaryColOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CurrentDayStyle")
+        }
+    }
+    static iscurves_Curve(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (curves.Curve.Linear)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.Ease)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.EaseIn)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.EaseOut)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.EaseInOut)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.FastOutSlowIn)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.LinearOutSlowIn)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.FastOutLinearIn)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.ExtremeDeceleration)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.Sharp)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.Rhythm)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.Smooth)) {
+            return true
+        }
+        else if ((value) === (curves.Curve.Friction)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof curves.Curve")
+        }
+    }
+    static iscurves_ICurve(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof curves.ICurve")
+    }
+    static isCustomDialogController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof CustomDialogController")
+    }
+    static isCustomDialogControllerOptions(value: Object | string | number | undefined | boolean, duplicated_builder: boolean, duplicated_cancel: boolean, duplicated_autoCancel: boolean, duplicated_alignment: boolean, duplicated_offset: boolean, duplicated_customStyle: boolean, duplicated_gridCount: boolean, duplicated_maskColor: boolean, duplicated_maskRect: boolean, duplicated_openAnimation: boolean, duplicated_closeAnimation: boolean, duplicated_showInSubWindow: boolean, duplicated_backgroundColor: boolean, duplicated_cornerRadius: boolean, duplicated_isModal: boolean, duplicated_onWillDismiss: boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_borderWidth: boolean, duplicated_borderColor: boolean, duplicated_borderStyle: boolean, duplicated_shadow: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_keyboardAvoidMode: boolean, duplicated_enableHoverMode: boolean, duplicated_hoverModeArea: boolean, duplicated_onDidAppear: boolean, duplicated_onDidDisappear: boolean, duplicated_onWillAppear: boolean, duplicated_onWillDisappear: boolean, duplicated_keyboardAvoidDistance: boolean, duplicated_levelMode: boolean, duplicated_levelUniqueId: boolean, duplicated_immersiveMode: boolean, duplicated_levelOrder: boolean, duplicated_focusable: boolean): boolean {
+        if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_cancel) && (value?.hasOwnProperty("cancel"))) {
+            return true
+        }
+        else if ((!duplicated_autoCancel) && (value?.hasOwnProperty("autoCancel"))) {
+            return true
+        }
+        else if ((!duplicated_alignment) && (value?.hasOwnProperty("alignment"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_customStyle) && (value?.hasOwnProperty("customStyle"))) {
+            return true
+        }
+        else if ((!duplicated_gridCount) && (value?.hasOwnProperty("gridCount"))) {
+            return true
+        }
+        else if ((!duplicated_maskColor) && (value?.hasOwnProperty("maskColor"))) {
+            return true
+        }
+        else if ((!duplicated_maskRect) && (value?.hasOwnProperty("maskRect"))) {
+            return true
+        }
+        else if ((!duplicated_openAnimation) && (value?.hasOwnProperty("openAnimation"))) {
+            return true
+        }
+        else if ((!duplicated_closeAnimation) && (value?.hasOwnProperty("closeAnimation"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_cornerRadius) && (value?.hasOwnProperty("cornerRadius"))) {
+            return true
+        }
+        else if ((!duplicated_isModal) && (value?.hasOwnProperty("isModal"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_borderColor) && (value?.hasOwnProperty("borderColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderStyle) && (value?.hasOwnProperty("borderStyle"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_keyboardAvoidMode) && (value?.hasOwnProperty("keyboardAvoidMode"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_hoverModeArea) && (value?.hasOwnProperty("hoverModeArea"))) {
+            return true
+        }
+        else if ((!duplicated_onDidAppear) && (value?.hasOwnProperty("onDidAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDidDisappear) && (value?.hasOwnProperty("onDidDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillAppear) && (value?.hasOwnProperty("onWillAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDisappear) && (value?.hasOwnProperty("onWillDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_keyboardAvoidDistance) && (value?.hasOwnProperty("keyboardAvoidDistance"))) {
+            return true
+        }
+        else if ((!duplicated_levelMode) && (value?.hasOwnProperty("levelMode"))) {
+            return true
+        }
+        else if ((!duplicated_levelUniqueId) && (value?.hasOwnProperty("levelUniqueId"))) {
+            return true
+        }
+        else if ((!duplicated_immersiveMode) && (value?.hasOwnProperty("immersiveMode"))) {
+            return true
+        }
+        else if ((!duplicated_levelOrder) && (value?.hasOwnProperty("levelOrder"))) {
+            return true
+        }
+        else if ((!duplicated_focusable) && (value?.hasOwnProperty("focusable"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomDialogControllerOptions")
+        }
+    }
+    static isCustomPopupOptions(value: Object | string | number | undefined | boolean, duplicated_builder: boolean, duplicated_placement: boolean, duplicated_popupColor: boolean, duplicated_enableArrow: boolean, duplicated_autoCancel: boolean, duplicated_onStateChange: boolean, duplicated_arrowOffset: boolean, duplicated_showInSubWindow: boolean, duplicated_mask: boolean, duplicated_targetSpace: boolean, duplicated_offset: boolean, duplicated_width: boolean, duplicated_arrowPointPosition: boolean, duplicated_arrowWidth: boolean, duplicated_arrowHeight: boolean, duplicated_radius: boolean, duplicated_shadow: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_focusable: boolean, duplicated_transition: boolean, duplicated_onWillDismiss: boolean, duplicated_enableHoverMode: boolean, duplicated_followTransformOfTarget: boolean, duplicated_keyboardAvoidMode: boolean): boolean {
+        if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_placement) && (value?.hasOwnProperty("placement"))) {
+            return true
+        }
+        else if ((!duplicated_popupColor) && (value?.hasOwnProperty("popupColor"))) {
+            return true
+        }
+        else if ((!duplicated_enableArrow) && (value?.hasOwnProperty("enableArrow"))) {
+            return true
+        }
+        else if ((!duplicated_autoCancel) && (value?.hasOwnProperty("autoCancel"))) {
+            return true
+        }
+        else if ((!duplicated_onStateChange) && (value?.hasOwnProperty("onStateChange"))) {
+            return true
+        }
+        else if ((!duplicated_arrowOffset) && (value?.hasOwnProperty("arrowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else if ((!duplicated_mask) && (value?.hasOwnProperty("mask"))) {
+            return true
+        }
+        else if ((!duplicated_targetSpace) && (value?.hasOwnProperty("targetSpace"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_arrowPointPosition) && (value?.hasOwnProperty("arrowPointPosition"))) {
+            return true
+        }
+        else if ((!duplicated_arrowWidth) && (value?.hasOwnProperty("arrowWidth"))) {
+            return true
+        }
+        else if ((!duplicated_arrowHeight) && (value?.hasOwnProperty("arrowHeight"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_focusable) && (value?.hasOwnProperty("focusable"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_followTransformOfTarget) && (value?.hasOwnProperty("followTransformOfTarget"))) {
+            return true
+        }
+        else if ((!duplicated_keyboardAvoidMode) && (value?.hasOwnProperty("keyboardAvoidMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomPopupOptions")
+        }
+    }
+    static isCustomSpan(value: Object | string | number | undefined | boolean, duplicated_onMeasure: boolean, duplicated_onDraw: boolean): boolean {
+        if ((!duplicated_onMeasure) && (value?.hasOwnProperty("onMeasure"))) {
+            return true
+        }
+        else if ((!duplicated_onDraw) && (value?.hasOwnProperty("onDraw"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomSpan")
+        }
+    }
+    static isCustomSpanDrawInfo(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_lineTop: boolean, duplicated_lineBottom: boolean, duplicated_baseline: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_lineTop) && (value?.hasOwnProperty("lineTop"))) {
+            return true
+        }
+        else if ((!duplicated_lineBottom) && (value?.hasOwnProperty("lineBottom"))) {
+            return true
+        }
+        else if ((!duplicated_baseline) && (value?.hasOwnProperty("baseline"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomSpanDrawInfo")
+        }
+    }
+    static isCustomSpanMeasureInfo(value: Object | string | number | undefined | boolean, duplicated_fontSize: boolean): boolean {
+        if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomSpanMeasureInfo")
+        }
+    }
+    static isCustomSpanMetrics(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomSpanMetrics")
+        }
+    }
+    static isCustomTheme(value: Object | string | number | undefined | boolean, duplicated_colors: boolean): boolean {
+        if ((!duplicated_colors) && (value?.hasOwnProperty("colors"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CustomTheme")
+        }
+    }
+    static isCutEvent(value: Object | string | number | undefined | boolean, duplicated_preventDefault: boolean): boolean {
+        if ((!duplicated_preventDefault) && (value?.hasOwnProperty("preventDefault"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof CutEvent")
+        }
+    }
+    static isDataOperationType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DataOperationType.ADD)) {
+            return true
+        }
+        else if ((value) === (DataOperationType.DELETE)) {
+            return true
+        }
+        else if ((value) === (DataOperationType.EXCHANGE)) {
+            return true
+        }
+        else if ((value) === (DataOperationType.MOVE)) {
+            return true
+        }
+        else if ((value) === (DataOperationType.CHANGE)) {
+            return true
+        }
+        else if ((value) === (DataOperationType.RELOAD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DataOperationType")
+        }
+    }
+    static isDataPanelConfiguration(value: Object | string | number | undefined | boolean, duplicated_values: boolean, duplicated_maxValue: boolean): boolean {
+        if ((!duplicated_values) && (value?.hasOwnProperty("values"))) {
+            return true
+        }
+        else if ((!duplicated_maxValue) && (value?.hasOwnProperty("maxValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DataPanelConfiguration")
+        }
+    }
+    static isDataPanelOptions(value: Object | string | number | undefined | boolean, duplicated_values: boolean, duplicated_max: boolean, duplicated_type: boolean): boolean {
+        if ((!duplicated_values) && (value?.hasOwnProperty("values"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DataPanelOptions")
+        }
+    }
+    static isDataPanelShadowOptions(value: Object | string | number | undefined | boolean, duplicated_colors: boolean): boolean {
+        if ((!duplicated_colors) && (value?.hasOwnProperty("colors"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DataPanelShadowOptions")
+        }
+    }
+    static isDataPanelType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DataPanelType.Line)) {
+            return true
+        }
+        else if ((value) === (DataPanelType.Circle)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DataPanelType")
+        }
+    }
+    static isDataResubmissionHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DataResubmissionHandler")
+    }
+    static isDatePickerDialog(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DatePickerDialog")
+    }
+    static isDatePickerMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DatePickerMode.DATE)) {
+            return true
+        }
+        else if ((value) === (DatePickerMode.YEAR_AND_MONTH)) {
+            return true
+        }
+        else if ((value) === (DatePickerMode.MONTH_AND_DAY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DatePickerMode")
+        }
+    }
+    static isDatePickerOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_selected: boolean, duplicated_mode: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_mode) && (value?.hasOwnProperty("mode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DatePickerOptions")
+        }
+    }
+    static isDateRange(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DateRange")
+        }
+    }
+    static isDecorationStyle(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_color: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DecorationStyle")
+        }
+    }
+    static isDecorationStyleInterface(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_color: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DecorationStyleInterface")
+        }
+    }
+    static isDecorationStyleResult(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_color: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DecorationStyleResult")
+        }
+    }
+    static isDeleteValue(value: Object | string | number | undefined | boolean, duplicated_deleteOffset: boolean, duplicated_direction: boolean, duplicated_deleteValue: boolean): boolean {
+        if ((!duplicated_deleteOffset) && (value?.hasOwnProperty("deleteOffset"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_deleteValue) && (value?.hasOwnProperty("deleteValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DeleteValue")
+        }
+    }
+    static isDialogAlignment(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DialogAlignment.Top)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.Center)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.Bottom)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.Default)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.TopStart)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.TopEnd)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.CenterStart)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.CenterEnd)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.BottomStart)) {
+            return true
+        }
+        else if ((value) === (DialogAlignment.BottomEnd)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DialogAlignment")
+        }
+    }
+    static isDialogButtonDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DialogButtonDirection.AUTO)) {
+            return true
+        }
+        else if ((value) === (DialogButtonDirection.HORIZONTAL)) {
+            return true
+        }
+        else if ((value) === (DialogButtonDirection.VERTICAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DialogButtonDirection")
+        }
+    }
+    static isDialogButtonStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DialogButtonStyle.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (DialogButtonStyle.HIGHLIGHT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DialogButtonStyle")
+        }
+    }
+    static isDigitIndicator(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DigitIndicator")
+    }
+    static isDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Direction.Ltr)) {
+            return true
+        }
+        else if ((value) === (Direction.Rtl)) {
+            return true
+        }
+        else if ((value) === (Direction.Auto)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Direction")
+        }
+    }
+    static isDirectionalEdgesT(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_top: boolean, duplicated_bottom: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DirectionalEdgesT")
+        }
+    }
+    static isDisappearSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_scope: boolean): boolean {
+        if ((!duplicated_scope) && (value?.hasOwnProperty("scope"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DisappearSymbolEffect")
+        }
+    }
+    static isDismissContentCoverAction(value: Object | string | number | undefined | boolean, duplicated_dismiss: boolean, duplicated_reason: boolean): boolean {
+        if ((!duplicated_dismiss) && (value?.hasOwnProperty("dismiss"))) {
+            return true
+        }
+        else if ((!duplicated_reason) && (value?.hasOwnProperty("reason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DismissContentCoverAction")
+        }
+    }
+    static isDismissDialogAction(value: Object | string | number | undefined | boolean, duplicated_reason: boolean): boolean {
+        if ((!duplicated_reason) && (value?.hasOwnProperty("reason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DismissDialogAction")
+        }
+    }
+    static isDismissPopupAction(value: Object | string | number | undefined | boolean, duplicated_reason: boolean): boolean {
+        if ((!duplicated_reason) && (value?.hasOwnProperty("reason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DismissPopupAction")
+        }
+    }
+    static isDismissReason(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DismissReason.PRESS_BACK)) {
+            return true
+        }
+        else if ((value) === (DismissReason.TOUCH_OUTSIDE)) {
+            return true
+        }
+        else if ((value) === (DismissReason.CLOSE_BUTTON)) {
+            return true
+        }
+        else if ((value) === (DismissReason.SLIDE_DOWN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DismissReason")
+        }
+    }
+    static isDismissSheetAction(value: Object | string | number | undefined | boolean, duplicated_dismiss: boolean, duplicated_reason: boolean): boolean {
+        if ((!duplicated_dismiss) && (value?.hasOwnProperty("dismiss"))) {
+            return true
+        }
+        else if ((!duplicated_reason) && (value?.hasOwnProperty("reason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DismissSheetAction")
+        }
+    }
+    static isDistributionType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DistributionType.UNIFORM)) {
+            return true
+        }
+        else if ((value) === (DistributionType.GAUSSIAN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DistributionType")
+        }
+    }
+    static isDisturbanceFieldShape(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DisturbanceFieldShape.RECT)) {
+            return true
+        }
+        else if ((value) === (DisturbanceFieldShape.CIRCLE)) {
+            return true
+        }
+        else if ((value) === (DisturbanceFieldShape.ELLIPSE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DisturbanceFieldShape")
+        }
+    }
+    static isDividerMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DividerMode.FLOATING_ABOVE_MENU)) {
+            return true
+        }
+        else if ((value) === (DividerMode.EMBEDDED_IN_MENU)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DividerMode")
+        }
+    }
+    static isDividerOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_color: boolean, duplicated_startMargin: boolean, duplicated_endMargin: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_startMargin) && (value?.hasOwnProperty("startMargin"))) {
+            return true
+        }
+        else if ((!duplicated_endMargin) && (value?.hasOwnProperty("endMargin"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DividerOptions")
+        }
+    }
+    static isDividerStyle(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_color: boolean, duplicated_startMargin: boolean, duplicated_endMargin: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_startMargin) && (value?.hasOwnProperty("startMargin"))) {
+            return true
+        }
+        else if ((!duplicated_endMargin) && (value?.hasOwnProperty("endMargin"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DividerStyle")
+        }
+    }
+    static isDividerStyleOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_color: boolean, duplicated_startMargin: boolean, duplicated_endMargin: boolean, duplicated_mode: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_startMargin) && (value?.hasOwnProperty("startMargin"))) {
+            return true
+        }
+        else if ((!duplicated_endMargin) && (value?.hasOwnProperty("endMargin"))) {
+            return true
+        }
+        else if ((!duplicated_mode) && (value?.hasOwnProperty("mode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DividerStyleOptions")
+        }
+    }
+    static isDotIndicator(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DotIndicator")
+    }
+    static isDoubleAnimationParam(value: Object | string | number | undefined | boolean, duplicated_propertyName: boolean, duplicated_startValue: boolean, duplicated_endValue: boolean, duplicated_duration: boolean, duplicated_delay: boolean, duplicated_curve: boolean, duplicated_onProgress: boolean, duplicated_onFinish: boolean): boolean {
+        if ((!duplicated_propertyName) && (value?.hasOwnProperty("propertyName"))) {
+            return true
+        }
+        else if ((!duplicated_startValue) && (value?.hasOwnProperty("startValue"))) {
+            return true
+        }
+        else if ((!duplicated_endValue) && (value?.hasOwnProperty("endValue"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else if ((!duplicated_delay) && (value?.hasOwnProperty("delay"))) {
+            return true
+        }
+        else if ((!duplicated_curve) && (value?.hasOwnProperty("curve"))) {
+            return true
+        }
+        else if ((!duplicated_onProgress) && (value?.hasOwnProperty("onProgress"))) {
+            return true
+        }
+        else if ((!duplicated_onFinish) && (value?.hasOwnProperty("onFinish"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DoubleAnimationParam")
+        }
+    }
+    static isDpiFollowStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DpiFollowStrategy.FOLLOW_HOST_DPI)) {
+            return true
+        }
+        else if ((value) === (DpiFollowStrategy.FOLLOW_UI_EXTENSION_ABILITY_DPI)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DpiFollowStrategy")
+        }
+    }
+    static isDragBehavior(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DragBehavior.COPY)) {
+            return true
+        }
+        else if ((value) === (DragBehavior.MOVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragBehavior")
+        }
+    }
+    static isDragEvent(value: Object | string | number | undefined | boolean, duplicated_dragBehavior: boolean, duplicated_useCustomDropAnimation: boolean, duplicated_getModifierKeyState: boolean): boolean {
+        if ((!duplicated_dragBehavior) && (value?.hasOwnProperty("dragBehavior"))) {
+            return true
+        }
+        else if ((!duplicated_useCustomDropAnimation) && (value?.hasOwnProperty("useCustomDropAnimation"))) {
+            return true
+        }
+        else if ((!duplicated_getModifierKeyState) && (value?.hasOwnProperty("getModifierKeyState"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragEvent")
+        }
+    }
+    static isDraggingSizeChangeEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DraggingSizeChangeEffect.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (DraggingSizeChangeEffect.SIZE_TRANSITION)) {
+            return true
+        }
+        else if ((value) === (DraggingSizeChangeEffect.SIZE_CONTENT_TRANSITION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DraggingSizeChangeEffect")
+        }
+    }
+    static isDragInteractionOptions(value: Object | string | number | undefined | boolean, duplicated_isMultiSelectionEnabled: boolean, duplicated_defaultAnimationBeforeLifting: boolean, duplicated_enableEdgeAutoScroll: boolean, duplicated_enableHapticFeedback: boolean, duplicated_isLiftingDisabled: boolean): boolean {
+        if ((!duplicated_isMultiSelectionEnabled) && (value?.hasOwnProperty("isMultiSelectionEnabled"))) {
+            return true
+        }
+        else if ((!duplicated_defaultAnimationBeforeLifting) && (value?.hasOwnProperty("defaultAnimationBeforeLifting"))) {
+            return true
+        }
+        else if ((!duplicated_enableEdgeAutoScroll) && (value?.hasOwnProperty("enableEdgeAutoScroll"))) {
+            return true
+        }
+        else if ((!duplicated_enableHapticFeedback) && (value?.hasOwnProperty("enableHapticFeedback"))) {
+            return true
+        }
+        else if ((!duplicated_isLiftingDisabled) && (value?.hasOwnProperty("isLiftingDisabled"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragInteractionOptions")
+        }
+    }
+    static isDragItemInfo(value: Object | string | number | undefined | boolean, duplicated_pixelMap: boolean, duplicated_builder: boolean, duplicated_extraInfo: boolean): boolean {
+        if ((!duplicated_pixelMap) && (value?.hasOwnProperty("pixelMap"))) {
+            return true
+        }
+        else if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_extraInfo) && (value?.hasOwnProperty("extraInfo"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragItemInfo")
+        }
+    }
+    static isDragPreviewMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DragPreviewMode.AUTO)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.DISABLE_SCALE)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.ENABLE_DEFAULT_SHADOW)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.ENABLE_DEFAULT_RADIUS)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.ENABLE_DRAG_ITEM_GRAY_EFFECT)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.ENABLE_MULTI_TILE_EFFECT)) {
+            return true
+        }
+        else if ((value) === (DragPreviewMode.ENABLE_TOUCH_POINT_CALCULATION_BASED_ON_FINAL_PREVIEW)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragPreviewMode")
+        }
+    }
+    static isDragPreviewOptions(value: Object | string | number | undefined | boolean, duplicated_mode: boolean, duplicated_numberBadge: boolean, duplicated_sizeChangeEffect: boolean): boolean {
+        if ((!duplicated_mode) && (value?.hasOwnProperty("mode"))) {
+            return true
+        }
+        else if ((!duplicated_numberBadge) && (value?.hasOwnProperty("numberBadge"))) {
+            return true
+        }
+        else if ((!duplicated_sizeChangeEffect) && (value?.hasOwnProperty("sizeChangeEffect"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragPreviewOptions")
+        }
+    }
+    static isDragResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DragResult.DRAG_SUCCESSFUL)) {
+            return true
+        }
+        else if ((value) === (DragResult.DRAG_FAILED)) {
+            return true
+        }
+        else if ((value) === (DragResult.DRAG_CANCELED)) {
+            return true
+        }
+        else if ((value) === (DragResult.DROP_ENABLED)) {
+            return true
+        }
+        else if ((value) === (DragResult.DROP_DISABLED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DragResult")
+        }
+    }
+    static isDrawableDescriptor(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DrawableDescriptor")
+    }
+    static isDrawContext(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof DrawContext")
+    }
+    static isdrawing_BlendMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.BlendMode.CLEAR)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SRC)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DST)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SRC_OVER)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DST_OVER)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SRC_IN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DST_IN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SRC_OUT)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DST_OUT)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SRC_ATOP)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DST_ATOP)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.XOR)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.PLUS)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.MODULATE)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SCREEN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.OVERLAY)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DARKEN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.LIGHTEN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.COLOR_DODGE)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.COLOR_BURN)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.HARD_LIGHT)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SOFT_LIGHT)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.EXCLUSION)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.MULTIPLY)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.HUE)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.SATURATION)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.COLOR)) {
+            return true
+        }
+        else if ((value) === (drawing.BlendMode.LUMINOSITY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.BlendMode")
+        }
+    }
+    static isdrawing_BlurType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.BlurType.NORMAL)) {
+            return true
+        }
+        else if ((value) === (drawing.BlurType.SOLID)) {
+            return true
+        }
+        else if ((value) === (drawing.BlurType.OUTER)) {
+            return true
+        }
+        else if ((value) === (drawing.BlurType.INNER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.BlurType")
+        }
+    }
+    static isdrawing_Brush(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Brush")
+    }
+    static isdrawing_Canvas(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Canvas")
+    }
+    static isdrawing_CapStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.CapStyle.FLAT_CAP)) {
+            return true
+        }
+        else if ((value) === (drawing.CapStyle.SQUARE_CAP)) {
+            return true
+        }
+        else if ((value) === (drawing.CapStyle.ROUND_CAP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.CapStyle")
+        }
+    }
+    static isdrawing_ClipOp(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.ClipOp.DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (drawing.ClipOp.INTERSECT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.ClipOp")
+        }
+    }
+    static isdrawing_ColorFilter(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.ColorFilter")
+    }
+    static isdrawing_CornerPos(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.CornerPos.TOP_LEFT_POS)) {
+            return true
+        }
+        else if ((value) === (drawing.CornerPos.TOP_RIGHT_POS)) {
+            return true
+        }
+        else if ((value) === (drawing.CornerPos.BOTTOM_RIGHT_POS)) {
+            return true
+        }
+        else if ((value) === (drawing.CornerPos.BOTTOM_LEFT_POS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.CornerPos")
+        }
+    }
+    static isdrawing_FilterMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.FilterMode.FILTER_MODE_NEAREST)) {
+            return true
+        }
+        else if ((value) === (drawing.FilterMode.FILTER_MODE_LINEAR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.FilterMode")
+        }
+    }
+    static isdrawing_Font(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Font")
+    }
+    static isdrawing_FontEdging(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.FontEdging.ALIAS)) {
+            return true
+        }
+        else if ((value) === (drawing.FontEdging.ANTI_ALIAS)) {
+            return true
+        }
+        else if ((value) === (drawing.FontEdging.SUBPIXEL_ANTI_ALIAS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.FontEdging")
+        }
+    }
+    static isdrawing_FontHinting(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.FontHinting.NONE)) {
+            return true
+        }
+        else if ((value) === (drawing.FontHinting.SLIGHT)) {
+            return true
+        }
+        else if ((value) === (drawing.FontHinting.NORMAL)) {
+            return true
+        }
+        else if ((value) === (drawing.FontHinting.FULL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.FontHinting")
+        }
+    }
+    static isdrawing_FontMetrics(value: Object | string | number | undefined | boolean, duplicated_flags: boolean, duplicated_top: boolean, duplicated_ascent: boolean, duplicated_descent: boolean, duplicated_bottom: boolean, duplicated_leading: boolean, duplicated_avgCharWidth: boolean, duplicated_maxCharWidth: boolean, duplicated_xMin: boolean, duplicated_xMax: boolean, duplicated_xHeight: boolean, duplicated_capHeight: boolean, duplicated_underlineThickness: boolean, duplicated_underlinePosition: boolean, duplicated_strikethroughThickness: boolean, duplicated_strikethroughPosition: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_ascent) && (value?.hasOwnProperty("ascent"))) {
+            return true
+        }
+        else if ((!duplicated_descent) && (value?.hasOwnProperty("descent"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_leading) && (value?.hasOwnProperty("leading"))) {
+            return true
+        }
+        else if ((!duplicated_flags) && (value?.hasOwnProperty("flags"))) {
+            return true
+        }
+        else if ((!duplicated_avgCharWidth) && (value?.hasOwnProperty("avgCharWidth"))) {
+            return true
+        }
+        else if ((!duplicated_maxCharWidth) && (value?.hasOwnProperty("maxCharWidth"))) {
+            return true
+        }
+        else if ((!duplicated_xMin) && (value?.hasOwnProperty("xMin"))) {
+            return true
+        }
+        else if ((!duplicated_xMax) && (value?.hasOwnProperty("xMax"))) {
+            return true
+        }
+        else if ((!duplicated_xHeight) && (value?.hasOwnProperty("xHeight"))) {
+            return true
+        }
+        else if ((!duplicated_capHeight) && (value?.hasOwnProperty("capHeight"))) {
+            return true
+        }
+        else if ((!duplicated_underlineThickness) && (value?.hasOwnProperty("underlineThickness"))) {
+            return true
+        }
+        else if ((!duplicated_underlinePosition) && (value?.hasOwnProperty("underlinePosition"))) {
+            return true
+        }
+        else if ((!duplicated_strikethroughThickness) && (value?.hasOwnProperty("strikethroughThickness"))) {
+            return true
+        }
+        else if ((!duplicated_strikethroughPosition) && (value?.hasOwnProperty("strikethroughPosition"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.FontMetrics")
+        }
+    }
+    static isdrawing_FontMetricsFlags(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.FontMetricsFlags.UNDERLINE_THICKNESS_VALID)) {
+            return true
+        }
+        else if ((value) === (drawing.FontMetricsFlags.UNDERLINE_POSITION_VALID)) {
+            return true
+        }
+        else if ((value) === (drawing.FontMetricsFlags.STRIKETHROUGH_THICKNESS_VALID)) {
+            return true
+        }
+        else if ((value) === (drawing.FontMetricsFlags.STRIKETHROUGH_POSITION_VALID)) {
+            return true
+        }
+        else if ((value) === (drawing.FontMetricsFlags.BOUNDS_INVALID)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.FontMetricsFlags")
+        }
+    }
+    static isdrawing_ImageFilter(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.ImageFilter")
+    }
+    static isdrawing_JoinStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.JoinStyle.MITER_JOIN)) {
+            return true
+        }
+        else if ((value) === (drawing.JoinStyle.ROUND_JOIN)) {
+            return true
+        }
+        else if ((value) === (drawing.JoinStyle.BEVEL_JOIN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.JoinStyle")
+        }
+    }
+    static isdrawing_Lattice(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Lattice")
+    }
+    static isdrawing_MaskFilter(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.MaskFilter")
+    }
+    static isdrawing_Matrix(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Matrix")
+    }
+    static isdrawing_Path(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Path")
+    }
+    static isdrawing_PathDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.PathDirection.CLOCKWISE)) {
+            return true
+        }
+        else if ((value) === (drawing.PathDirection.COUNTER_CLOCKWISE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.PathDirection")
+        }
+    }
+    static isdrawing_PathEffect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.PathEffect")
+    }
+    static isdrawing_PathFillType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.PathFillType.WINDING)) {
+            return true
+        }
+        else if ((value) === (drawing.PathFillType.EVEN_ODD)) {
+            return true
+        }
+        else if ((value) === (drawing.PathFillType.INVERSE_WINDING)) {
+            return true
+        }
+        else if ((value) === (drawing.PathFillType.INVERSE_EVEN_ODD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.PathFillType")
+        }
+    }
+    static isdrawing_PathMeasureMatrixFlags(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.PathMeasureMatrixFlags.GET_POSITION_MATRIX)) {
+            return true
+        }
+        else if ((value) === (drawing.PathMeasureMatrixFlags.GET_TANGENT_MATRIX)) {
+            return true
+        }
+        else if ((value) === (drawing.PathMeasureMatrixFlags.GET_POSITION_AND_TANGENT_MATRIX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.PathMeasureMatrixFlags")
+        }
+    }
+    static isdrawing_PathOp(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.PathOp.DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (drawing.PathOp.INTERSECT)) {
+            return true
+        }
+        else if ((value) === (drawing.PathOp.UNION)) {
+            return true
+        }
+        else if ((value) === (drawing.PathOp.XOR)) {
+            return true
+        }
+        else if ((value) === (drawing.PathOp.REVERSE_DIFFERENCE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.PathOp")
+        }
+    }
+    static isdrawing_Pen(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Pen")
+    }
+    static isdrawing_PointMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.PointMode.POINTS)) {
+            return true
+        }
+        else if ((value) === (drawing.PointMode.LINES)) {
+            return true
+        }
+        else if ((value) === (drawing.PointMode.POLYGON)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.PointMode")
+        }
+    }
+    static isdrawing_RectType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.RectType.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (drawing.RectType.TRANSPARENT)) {
+            return true
+        }
+        else if ((value) === (drawing.RectType.FIXEDCOLOR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.RectType")
+        }
+    }
+    static isdrawing_Region(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Region")
+    }
+    static isdrawing_RegionOp(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.RegionOp.DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (drawing.RegionOp.INTERSECT)) {
+            return true
+        }
+        else if ((value) === (drawing.RegionOp.UNION)) {
+            return true
+        }
+        else if ((value) === (drawing.RegionOp.XOR)) {
+            return true
+        }
+        else if ((value) === (drawing.RegionOp.REVERSE_DIFFERENCE)) {
+            return true
+        }
+        else if ((value) === (drawing.RegionOp.REPLACE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.RegionOp")
+        }
+    }
+    static isdrawing_RoundRect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.RoundRect")
+    }
+    static isdrawing_SamplingOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.SamplingOptions")
+    }
+    static isdrawing_ScaleToFit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.ScaleToFit.FILL_SCALE_TO_FIT)) {
+            return true
+        }
+        else if ((value) === (drawing.ScaleToFit.START_SCALE_TO_FIT)) {
+            return true
+        }
+        else if ((value) === (drawing.ScaleToFit.CENTER_SCALE_TO_FIT)) {
+            return true
+        }
+        else if ((value) === (drawing.ScaleToFit.END_SCALE_TO_FIT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.ScaleToFit")
+        }
+    }
+    static isdrawing_ShaderEffect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.ShaderEffect")
+    }
+    static isdrawing_ShadowFlag(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.ShadowFlag.NONE)) {
+            return true
+        }
+        else if ((value) === (drawing.ShadowFlag.TRANSPARENT_OCCLUDER)) {
+            return true
+        }
+        else if ((value) === (drawing.ShadowFlag.GEOMETRIC_ONLY)) {
+            return true
+        }
+        else if ((value) === (drawing.ShadowFlag.ALL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.ShadowFlag")
+        }
+    }
+    static isdrawing_ShadowLayer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.ShadowLayer")
+    }
+    static isdrawing_SrcRectConstraint(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.SrcRectConstraint.STRICT)) {
+            return true
+        }
+        else if ((value) === (drawing.SrcRectConstraint.FAST)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.SrcRectConstraint")
+        }
+    }
+    static isdrawing_TextBlob(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.TextBlob")
+    }
+    static isdrawing_TextBlobRunBuffer(value: Object | string | number | undefined | boolean, duplicated_glyph: boolean, duplicated_positionX: boolean, duplicated_positionY: boolean): boolean {
+        if ((!duplicated_glyph) && (value?.hasOwnProperty("glyph"))) {
+            return true
+        }
+        else if ((!duplicated_positionX) && (value?.hasOwnProperty("positionX"))) {
+            return true
+        }
+        else if ((!duplicated_positionY) && (value?.hasOwnProperty("positionY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.TextBlobRunBuffer")
+        }
+    }
+    static isdrawing_TextEncoding(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.TextEncoding.TEXT_ENCODING_UTF8)) {
+            return true
+        }
+        else if ((value) === (drawing.TextEncoding.TEXT_ENCODING_UTF16)) {
+            return true
+        }
+        else if ((value) === (drawing.TextEncoding.TEXT_ENCODING_UTF32)) {
+            return true
+        }
+        else if ((value) === (drawing.TextEncoding.TEXT_ENCODING_GLYPH_ID)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.TextEncoding")
+        }
+    }
+    static isdrawing_TileMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (drawing.TileMode.CLAMP)) {
+            return true
+        }
+        else if ((value) === (drawing.TileMode.REPEAT)) {
+            return true
+        }
+        else if ((value) === (drawing.TileMode.MIRROR)) {
+            return true
+        }
+        else if ((value) === (drawing.TileMode.DECAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof drawing.TileMode")
+        }
+    }
+    static isdrawing_Typeface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof drawing.Typeface")
+    }
+    static isDrawingRenderingContext(value: Object | string | number | undefined | boolean, duplicated_size: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DrawingRenderingContext")
+        }
+    }
+    static isDrawModifier(value: Object | string | number | undefined | boolean, duplicated_drawBehind_callback: boolean, duplicated_drawContent_callback: boolean): boolean {
+        if ((!duplicated_drawBehind_callback) && (value?.hasOwnProperty("drawBehind_callback"))) {
+            return true
+        }
+        else if ((!duplicated_drawContent_callback) && (value?.hasOwnProperty("drawContent_callback"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DrawModifier")
+        }
+    }
+    static isDropOptions(value: Object | string | number | undefined | boolean, duplicated_disableDataPrefetch: boolean): boolean {
+        if ((!duplicated_disableDataPrefetch) && (value?.hasOwnProperty("disableDataPrefetch"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DropOptions")
+        }
+    }
+    static isDynamicRangeMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (DynamicRangeMode.HIGH)) {
+            return true
+        }
+        else if ((value) === (DynamicRangeMode.CONSTRAINT)) {
+            return true
+        }
+        else if ((value) === (DynamicRangeMode.STANDARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof DynamicRangeMode")
+        }
+    }
+    static isEdge(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Edge.Top)) {
+            return true
+        }
+        else if ((value) === (Edge.Bottom)) {
+            return true
+        }
+        else if ((value) === (Edge.Start)) {
+            return true
+        }
+        else if ((value) === (Edge.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Edge")
+        }
+    }
+    static isEdgeColors(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeColors")
+        }
+    }
+    static isEdgeEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EdgeEffect.Spring)) {
+            return true
+        }
+        else if ((value) === (EdgeEffect.Fade)) {
+            return true
+        }
+        else if ((value) === (EdgeEffect.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeEffect")
+        }
+    }
+    static isEdgeEffectOptions(value: Object | string | number | undefined | boolean, duplicated_alwaysEnabled: boolean, duplicated_effectEdge: boolean): boolean {
+        if ((!duplicated_alwaysEnabled) && (value?.hasOwnProperty("alwaysEnabled"))) {
+            return true
+        }
+        else if ((!duplicated_effectEdge) && (value?.hasOwnProperty("effectEdge"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeEffectOptions")
+        }
+    }
+    static isEdgeOutlineStyles(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeOutlineStyles")
+        }
+    }
+    static isEdgeOutlineWidths(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeOutlineWidths")
+        }
+    }
+    static isEdges(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_left: boolean, duplicated_bottom: boolean, duplicated_right: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Edges")
+        }
+    }
+    static isEdgeStyles(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeStyles")
+        }
+    }
+    static isEdgeWidths(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EdgeWidths")
+        }
+    }
+    static isEditableTextChangeValue(value: Object | string | number | undefined | boolean, duplicated_content: boolean, duplicated_previewText: boolean, duplicated_options: boolean): boolean {
+        if ((!duplicated_content) && (value?.hasOwnProperty("content"))) {
+            return true
+        }
+        else if ((!duplicated_previewText) && (value?.hasOwnProperty("previewText"))) {
+            return true
+        }
+        else if ((!duplicated_options) && (value?.hasOwnProperty("options"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EditableTextChangeValue")
+        }
+    }
+    static isEditMenuOptions(value: Object | string | number | undefined | boolean, duplicated_onCreateMenu: boolean, duplicated_onMenuItemClick: boolean): boolean {
+        if ((!duplicated_onCreateMenu) && (value?.hasOwnProperty("onCreateMenu"))) {
+            return true
+        }
+        else if ((!duplicated_onMenuItemClick) && (value?.hasOwnProperty("onMenuItemClick"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EditMenuOptions")
+        }
+    }
+    static isEffectDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EffectDirection.DOWN)) {
+            return true
+        }
+        else if ((value) === (EffectDirection.UP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EffectDirection")
+        }
+    }
+    static isEffectEdge(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EffectEdge.START)) {
+            return true
+        }
+        else if ((value) === (EffectEdge.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EffectEdge")
+        }
+    }
+    static isEffectFillStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EffectFillStyle.CUMULATIVE)) {
+            return true
+        }
+        else if ((value) === (EffectFillStyle.ITERATIVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EffectFillStyle")
+        }
+    }
+    static isEffectScope(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EffectScope.LAYER)) {
+            return true
+        }
+        else if ((value) === (EffectScope.WHOLE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EffectScope")
+        }
+    }
+    static isEffectType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EffectType.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (EffectType.WINDOW_EFFECT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EffectType")
+        }
+    }
+    static isEllipseOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof EllipseOptions")
+    }
+    static isEllipseShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof EllipseShape")
+    }
+    static isEllipsisMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EllipsisMode.START)) {
+            return true
+        }
+        else if ((value) === (EllipsisMode.CENTER)) {
+            return true
+        }
+        else if ((value) === (EllipsisMode.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EllipsisMode")
+        }
+    }
+    static isEmbeddedType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EmbeddedType.EMBEDDED_UI_EXTENSION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EmbeddedType")
+        }
+    }
+    static isEmbedOptions(value: Object | string | number | undefined | boolean, duplicated_supportDefaultIntrinsicSize: boolean): boolean {
+        if ((!duplicated_supportDefaultIntrinsicSize) && (value?.hasOwnProperty("supportDefaultIntrinsicSize"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EmbedOptions")
+        }
+    }
+    static isEnterKeyType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (EnterKeyType.Go)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.Search)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.Send)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.Next)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.Done)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.PREVIOUS)) {
+            return true
+        }
+        else if ((value) === (EnterKeyType.NEW_LINE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EnterKeyType")
+        }
+    }
+    static isErrorEvent(value: Object | string | number | undefined | boolean, duplicated_message: boolean, duplicated_filename: boolean, duplicated_lineno: boolean, duplicated_colno: boolean, duplicated_error: boolean): boolean {
+        if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_filename) && (value?.hasOwnProperty("filename"))) {
+            return true
+        }
+        else if ((!duplicated_lineno) && (value?.hasOwnProperty("lineno"))) {
+            return true
+        }
+        else if ((!duplicated_colno) && (value?.hasOwnProperty("colno"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ErrorEvent")
+        }
+    }
+    static isErrorInformation(value: Object | string | number | undefined | boolean, duplicated_errcode: boolean, duplicated_msg: boolean): boolean {
+        if ((!duplicated_errcode) && (value?.hasOwnProperty("errcode"))) {
+            return true
+        }
+        else if ((!duplicated_msg) && (value?.hasOwnProperty("msg"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ErrorInformation")
+        }
+    }
+    static isEvent(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_timeStamp: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_timeStamp) && (value?.hasOwnProperty("timeStamp"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Event")
+        }
+    }
+    static isEventResult(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof EventResult")
+    }
+    static isEventTarget(value: Object | string | number | undefined | boolean, duplicated_area: boolean, duplicated_id: boolean): boolean {
+        if ((!duplicated_area) && (value?.hasOwnProperty("area"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof EventTarget")
+        }
+    }
+    static isEventTargetInfo(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof EventTargetInfo")
+    }
+    static isExpectedFrameRateRange(value: Object | string | number | undefined | boolean, duplicated_min: boolean, duplicated_max: boolean, duplicated_expected: boolean): boolean {
+        if ((!duplicated_min) && (value?.hasOwnProperty("min"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else if ((!duplicated_expected) && (value?.hasOwnProperty("expected"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ExpectedFrameRateRange")
+        }
+    }
+    static isExtendableComponent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ExtendableComponent")
+    }
+    static isFadingEdgeOptions(value: Object | string | number | undefined | boolean, duplicated_fadingEdgeLength: boolean): boolean {
+        if ((!duplicated_fadingEdgeLength) && (value?.hasOwnProperty("fadingEdgeLength"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FadingEdgeOptions")
+        }
+    }
+    static isFileSelectorMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FileSelectorMode.FileOpenMode)) {
+            return true
+        }
+        else if ((value) === (FileSelectorMode.FileOpenMultipleMode)) {
+            return true
+        }
+        else if ((value) === (FileSelectorMode.FileOpenFolderMode)) {
+            return true
+        }
+        else if ((value) === (FileSelectorMode.FileSaveMode)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FileSelectorMode")
+        }
+    }
+    static isFileSelectorParam(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof FileSelectorParam")
+    }
+    static isFileSelectorResult(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof FileSelectorResult")
+    }
+    static isFillMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FillMode.None)) {
+            return true
+        }
+        else if ((value) === (FillMode.Forwards)) {
+            return true
+        }
+        else if ((value) === (FillMode.Backwards)) {
+            return true
+        }
+        else if ((value) === (FillMode.Both)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FillMode")
+        }
+    }
+    static isFingerInfo(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_globalX: boolean, duplicated_globalY: boolean, duplicated_localX: boolean, duplicated_localY: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_hand: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_globalX) && (value?.hasOwnProperty("globalX"))) {
+            return true
+        }
+        else if ((!duplicated_globalY) && (value?.hasOwnProperty("globalY"))) {
+            return true
+        }
+        else if ((!duplicated_localX) && (value?.hasOwnProperty("localX"))) {
+            return true
+        }
+        else if ((!duplicated_localY) && (value?.hasOwnProperty("localY"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_hand) && (value?.hasOwnProperty("hand"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FingerInfo")
+        }
+    }
+    static isFinishCallbackType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FinishCallbackType.REMOVED)) {
+            return true
+        }
+        else if ((value) === (FinishCallbackType.LOGICALLY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FinishCallbackType")
+        }
+    }
+    static isFirstMeaningfulPaint(value: Object | string | number | undefined | boolean, duplicated_navigationStartTime: boolean, duplicated_firstMeaningfulPaintTime: boolean): boolean {
+        if ((!duplicated_navigationStartTime) && (value?.hasOwnProperty("navigationStartTime"))) {
+            return true
+        }
+        else if ((!duplicated_firstMeaningfulPaintTime) && (value?.hasOwnProperty("firstMeaningfulPaintTime"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FirstMeaningfulPaint")
+        }
+    }
+    static isFlexAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FlexAlign.Start)) {
+            return true
+        }
+        else if ((value) === (FlexAlign.Center)) {
+            return true
+        }
+        else if ((value) === (FlexAlign.End)) {
+            return true
+        }
+        else if ((value) === (FlexAlign.SpaceBetween)) {
+            return true
+        }
+        else if ((value) === (FlexAlign.SpaceAround)) {
+            return true
+        }
+        else if ((value) === (FlexAlign.SpaceEvenly)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FlexAlign")
+        }
+    }
+    static isFlexDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FlexDirection.Row)) {
+            return true
+        }
+        else if ((value) === (FlexDirection.Column)) {
+            return true
+        }
+        else if ((value) === (FlexDirection.RowReverse)) {
+            return true
+        }
+        else if ((value) === (FlexDirection.ColumnReverse)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FlexDirection")
+        }
+    }
+    static isFlexOptions(value: Object | string | number | undefined | boolean, duplicated_direction: boolean, duplicated_wrap: boolean, duplicated_justifyContent: boolean, duplicated_alignItems: boolean, duplicated_alignContent: boolean, duplicated_space: boolean): boolean {
+        if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_wrap) && (value?.hasOwnProperty("wrap"))) {
+            return true
+        }
+        else if ((!duplicated_justifyContent) && (value?.hasOwnProperty("justifyContent"))) {
+            return true
+        }
+        else if ((!duplicated_alignItems) && (value?.hasOwnProperty("alignItems"))) {
+            return true
+        }
+        else if ((!duplicated_alignContent) && (value?.hasOwnProperty("alignContent"))) {
+            return true
+        }
+        else if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FlexOptions")
+        }
+    }
+    static isFlexSpaceOptions(value: Object | string | number | undefined | boolean, duplicated_main: boolean, duplicated_cross: boolean): boolean {
+        if ((!duplicated_main) && (value?.hasOwnProperty("main"))) {
+            return true
+        }
+        else if ((!duplicated_cross) && (value?.hasOwnProperty("cross"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FlexSpaceOptions")
+        }
+    }
+    static isFlexWrap(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FlexWrap.NoWrap)) {
+            return true
+        }
+        else if ((value) === (FlexWrap.Wrap)) {
+            return true
+        }
+        else if ((value) === (FlexWrap.WrapReverse)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FlexWrap")
+        }
+    }
+    static isFocusAxisEvent(value: Object | string | number | undefined | boolean, duplicated_axisMap: boolean, duplicated_stopPropagation: boolean): boolean {
+        if ((!duplicated_axisMap) && (value?.hasOwnProperty("axisMap"))) {
+            return true
+        }
+        else if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FocusAxisEvent")
+        }
+    }
+    static isFocusBoxStyle(value: Object | string | number | undefined | boolean, duplicated_margin: boolean, duplicated_strokeColor: boolean, duplicated_strokeWidth: boolean): boolean {
+        if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_strokeColor) && (value?.hasOwnProperty("strokeColor"))) {
+            return true
+        }
+        else if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FocusBoxStyle")
+        }
+    }
+    static isFocusDrawLevel(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FocusDrawLevel.SELF)) {
+            return true
+        }
+        else if ((value) === (FocusDrawLevel.TOP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FocusDrawLevel")
+        }
+    }
+    static isFocusMovement(value: Object | string | number | undefined | boolean, duplicated_forward: boolean, duplicated_backward: boolean, duplicated_up: boolean, duplicated_down: boolean, duplicated_left: boolean, duplicated_right: boolean): boolean {
+        if ((!duplicated_forward) && (value?.hasOwnProperty("forward"))) {
+            return true
+        }
+        else if ((!duplicated_backward) && (value?.hasOwnProperty("backward"))) {
+            return true
+        }
+        else if ((!duplicated_up) && (value?.hasOwnProperty("up"))) {
+            return true
+        }
+        else if ((!duplicated_down) && (value?.hasOwnProperty("down"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FocusMovement")
+        }
+    }
+    static isFocusPriority(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FocusPriority.AUTO)) {
+            return true
+        }
+        else if ((value) === (FocusPriority.PRIOR)) {
+            return true
+        }
+        else if ((value) === (FocusPriority.PREVIOUS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FocusPriority")
+        }
+    }
+    static isFolderStackOptions(value: Object | string | number | undefined | boolean, duplicated_upperItems: boolean): boolean {
+        if ((!duplicated_upperItems) && (value?.hasOwnProperty("upperItems"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FolderStackOptions")
+        }
+    }
+    static isFoldStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FoldStatus.FOLD_STATUS_UNKNOWN)) {
+            return true
+        }
+        else if ((value) === (FoldStatus.FOLD_STATUS_EXPANDED)) {
+            return true
+        }
+        else if ((value) === (FoldStatus.FOLD_STATUS_FOLDED)) {
+            return true
+        }
+        else if ((value) === (FoldStatus.FOLD_STATUS_HALF_FOLDED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FoldStatus")
+        }
+    }
+    static isFont(value: Object | string | number | undefined | boolean, duplicated_size: boolean, duplicated_weight: boolean, duplicated_family: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_weight) && (value?.hasOwnProperty("weight"))) {
+            return true
+        }
+        else if ((!duplicated_family) && (value?.hasOwnProperty("family"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Font")
+        }
+    }
+    static isfont_UIFontAdjustInfo(value: Object | string | number | undefined | boolean, duplicated_weight: boolean, duplicated_to: boolean): boolean {
+        if ((!duplicated_weight) && (value?.hasOwnProperty("weight"))) {
+            return true
+        }
+        else if ((!duplicated_to) && (value?.hasOwnProperty("to"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontAdjustInfo")
+        }
+    }
+    static isfont_UIFontAliasInfo(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_weight: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_weight) && (value?.hasOwnProperty("weight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontAliasInfo")
+        }
+    }
+    static isfont_UIFontConfig(value: Object | string | number | undefined | boolean, duplicated_fontDir: boolean, duplicated_generic: boolean, duplicated_fallbackGroups: boolean): boolean {
+        if ((!duplicated_fontDir) && (value?.hasOwnProperty("fontDir"))) {
+            return true
+        }
+        else if ((!duplicated_generic) && (value?.hasOwnProperty("generic"))) {
+            return true
+        }
+        else if ((!duplicated_fallbackGroups) && (value?.hasOwnProperty("fallbackGroups"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontConfig")
+        }
+    }
+    static isfont_UIFontFallbackGroupInfo(value: Object | string | number | undefined | boolean, duplicated_fontSetName: boolean, duplicated_fallback: boolean): boolean {
+        if ((!duplicated_fontSetName) && (value?.hasOwnProperty("fontSetName"))) {
+            return true
+        }
+        else if ((!duplicated_fallback) && (value?.hasOwnProperty("fallback"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontFallbackGroupInfo")
+        }
+    }
+    static isfont_UIFontFallbackInfo(value: Object | string | number | undefined | boolean, duplicated_language: boolean, duplicated_family: boolean): boolean {
+        if ((!duplicated_language) && (value?.hasOwnProperty("language"))) {
+            return true
+        }
+        else if ((!duplicated_family) && (value?.hasOwnProperty("family"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontFallbackInfo")
+        }
+    }
+    static isfont_UIFontGenericInfo(value: Object | string | number | undefined | boolean, duplicated_family: boolean, duplicated_alias: boolean, duplicated_adjust: boolean): boolean {
+        if ((!duplicated_family) && (value?.hasOwnProperty("family"))) {
+            return true
+        }
+        else if ((!duplicated_alias) && (value?.hasOwnProperty("alias"))) {
+            return true
+        }
+        else if ((!duplicated_adjust) && (value?.hasOwnProperty("adjust"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof font.UIFontGenericInfo")
+        }
+    }
+    static isFontInfo(value: Object | string | number | undefined | boolean, duplicated_path: boolean, duplicated_postScriptName: boolean, duplicated_fullName: boolean, duplicated_family: boolean, duplicated_subfamily: boolean, duplicated_weight: boolean, duplicated_width: boolean, duplicated_italic: boolean, duplicated_monoSpace: boolean, duplicated_symbolic: boolean): boolean {
+        if ((!duplicated_path) && (value?.hasOwnProperty("path"))) {
+            return true
+        }
+        else if ((!duplicated_postScriptName) && (value?.hasOwnProperty("postScriptName"))) {
+            return true
+        }
+        else if ((!duplicated_fullName) && (value?.hasOwnProperty("fullName"))) {
+            return true
+        }
+        else if ((!duplicated_family) && (value?.hasOwnProperty("family"))) {
+            return true
+        }
+        else if ((!duplicated_subfamily) && (value?.hasOwnProperty("subfamily"))) {
+            return true
+        }
+        else if ((!duplicated_weight) && (value?.hasOwnProperty("weight"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_italic) && (value?.hasOwnProperty("italic"))) {
+            return true
+        }
+        else if ((!duplicated_monoSpace) && (value?.hasOwnProperty("monoSpace"))) {
+            return true
+        }
+        else if ((!duplicated_symbolic) && (value?.hasOwnProperty("symbolic"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FontInfo")
+        }
+    }
+    static isFontOptions(value: Object | string | number | undefined | boolean, duplicated_familyName: boolean, duplicated_familySrc: boolean): boolean {
+        if ((!duplicated_familyName) && (value?.hasOwnProperty("familyName"))) {
+            return true
+        }
+        else if ((!duplicated_familySrc) && (value?.hasOwnProperty("familySrc"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FontOptions")
+        }
+    }
+    static isFontSettingOptions(value: Object | string | number | undefined | boolean, duplicated_enableVariableFontWeight: boolean): boolean {
+        if ((!duplicated_enableVariableFontWeight) && (value?.hasOwnProperty("enableVariableFontWeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FontSettingOptions")
+        }
+    }
+    static isFontStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FontStyle.Normal)) {
+            return true
+        }
+        else if ((value) === (FontStyle.Italic)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FontStyle")
+        }
+    }
+    static isFontWeight(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FontWeight.Lighter)) {
+            return true
+        }
+        else if ((value) === (FontWeight.Normal)) {
+            return true
+        }
+        else if ((value) === (FontWeight.Regular)) {
+            return true
+        }
+        else if ((value) === (FontWeight.Medium)) {
+            return true
+        }
+        else if ((value) === (FontWeight.Bold)) {
+            return true
+        }
+        else if ((value) === (FontWeight.Bolder)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FontWeight")
+        }
+    }
+    static isForegroundBlurStyleOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ForegroundBlurStyleOptions")
+    }
+    static isForegroundEffectOptions(value: Object | string | number | undefined | boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ForegroundEffectOptions")
+        }
+    }
+    static isFormCallbackInfo(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_idString: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_idString) && (value?.hasOwnProperty("idString"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormCallbackInfo")
+        }
+    }
+    static isFormDimension(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FormDimension.Dimension_1_2)) {
+            return true
+        }
+        else if ((value) === (FormDimension.Dimension_2_2)) {
+            return true
+        }
+        else if ((value) === (FormDimension.Dimension_2_4)) {
+            return true
+        }
+        else if ((value) === (FormDimension.Dimension_4_4)) {
+            return true
+        }
+        else if ((value) === (FormDimension.DIMENSION_1_1)) {
+            return true
+        }
+        else if ((value) === (FormDimension.DIMENSION_6_4)) {
+            return true
+        }
+        else if ((value) === (FormDimension.DIMENSION_2_3)) {
+            return true
+        }
+        else if ((value) === (FormDimension.DIMENSION_3_3)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormDimension")
+        }
+    }
+    static isFormInfo(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_name: boolean, duplicated_bundle: boolean, duplicated_ability: boolean, duplicated_module: boolean, duplicated_dimension: boolean, duplicated_temporary: boolean, duplicated_want: boolean, duplicated_renderingMode: boolean, duplicated_shape: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_bundle) && (value?.hasOwnProperty("bundle"))) {
+            return true
+        }
+        else if ((!duplicated_ability) && (value?.hasOwnProperty("ability"))) {
+            return true
+        }
+        else if ((!duplicated_module) && (value?.hasOwnProperty("module"))) {
+            return true
+        }
+        else if ((!duplicated_dimension) && (value?.hasOwnProperty("dimension"))) {
+            return true
+        }
+        else if ((!duplicated_temporary) && (value?.hasOwnProperty("temporary"))) {
+            return true
+        }
+        else if ((!duplicated_want) && (value?.hasOwnProperty("want"))) {
+            return true
+        }
+        else if ((!duplicated_renderingMode) && (value?.hasOwnProperty("renderingMode"))) {
+            return true
+        }
+        else if ((!duplicated_shape) && (value?.hasOwnProperty("shape"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormInfo")
+        }
+    }
+    static isFormLinkOptions(value: Object | string | number | undefined | boolean, duplicated_action: boolean, duplicated_moduleName: boolean, duplicated_bundleName: boolean, duplicated_abilityName: boolean, duplicated_uri: boolean, duplicated_params: boolean): boolean {
+        if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_moduleName) && (value?.hasOwnProperty("moduleName"))) {
+            return true
+        }
+        else if ((!duplicated_bundleName) && (value?.hasOwnProperty("bundleName"))) {
+            return true
+        }
+        else if ((!duplicated_abilityName) && (value?.hasOwnProperty("abilityName"))) {
+            return true
+        }
+        else if ((!duplicated_uri) && (value?.hasOwnProperty("uri"))) {
+            return true
+        }
+        else if ((!duplicated_params) && (value?.hasOwnProperty("params"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormLinkOptions")
+        }
+    }
+    static isFormRenderingMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FormRenderingMode.FULL_COLOR)) {
+            return true
+        }
+        else if ((value) === (FormRenderingMode.SINGLE_COLOR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormRenderingMode")
+        }
+    }
+    static isFormShape(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FormShape.RECT)) {
+            return true
+        }
+        else if ((value) === (FormShape.CIRCLE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormShape")
+        }
+    }
+    static isFormSize(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FormSize")
+        }
+    }
+    static isFrame(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Frame")
+        }
+    }
+    static isFrameNode(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof FrameNode")
+    }
+    static isFrictionMotion(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof FrictionMotion")
+    }
+    static isFullScreenEnterEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean, duplicated_videoWidth: boolean, duplicated_videoHeight: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else if ((!duplicated_videoWidth) && (value?.hasOwnProperty("videoWidth"))) {
+            return true
+        }
+        else if ((!duplicated_videoHeight) && (value?.hasOwnProperty("videoHeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FullScreenEnterEvent")
+        }
+    }
+    static isFullScreenExitHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof FullScreenExitHandler")
+    }
+    static isFullscreenInfo(value: Object | string | number | undefined | boolean, duplicated_fullscreen: boolean): boolean {
+        if ((!duplicated_fullscreen) && (value?.hasOwnProperty("fullscreen"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FullscreenInfo")
+        }
+    }
+    static isFunctionKey(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (FunctionKey.ESC)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F1)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F2)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F3)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F4)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F5)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F6)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F7)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F8)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F9)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F10)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F11)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.F12)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.TAB)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.DPAD_UP)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.DPAD_DOWN)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.DPAD_LEFT)) {
+            return true
+        }
+        else if ((value) === (FunctionKey.DPAD_RIGHT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof FunctionKey")
+        }
+    }
+    static isGaugeConfiguration(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_min: boolean, duplicated_max: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_min) && (value?.hasOwnProperty("min"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GaugeConfiguration")
+        }
+    }
+    static isGaugeIndicatorOptions(value: Object | string | number | undefined | boolean, duplicated_icon: boolean, duplicated_space: boolean): boolean {
+        if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GaugeIndicatorOptions")
+        }
+    }
+    static isGaugeOptions(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_min: boolean, duplicated_max: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_min) && (value?.hasOwnProperty("min"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GaugeOptions")
+        }
+    }
+    static isGaugeShadowOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof GaugeShadowOptions")
+    }
+    static isGeometryInfo(value: Object | string | number | undefined | boolean, duplicated_borderWidth: boolean, duplicated_margin: boolean, duplicated_padding: boolean): boolean {
+        if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_padding) && (value?.hasOwnProperty("padding"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GeometryInfo")
+        }
+    }
+    static isGeometryTransitionOptions(value: Object | string | number | undefined | boolean, duplicated_follow: boolean, duplicated_hierarchyStrategy: boolean): boolean {
+        if ((!duplicated_follow) && (value?.hasOwnProperty("follow"))) {
+            return true
+        }
+        else if ((!duplicated_hierarchyStrategy) && (value?.hasOwnProperty("hierarchyStrategy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GeometryTransitionOptions")
+        }
+    }
+    static isGesture(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof Gesture")
+    }
+    static isGestureControl_GestureType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GestureControl.GestureType.TAP_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.LONG_PRESS_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.PAN_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.PINCH_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.SWIPE_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.ROTATION_GESTURE)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.DRAG)) {
+            return true
+        }
+        else if ((value) === (GestureControl.GestureType.CLICK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureControl.GestureType")
+        }
+    }
+    static isGestureEvent(value: Object | string | number | undefined | boolean, duplicated_repeat: boolean, duplicated_fingerList: boolean, duplicated_offsetX: boolean, duplicated_offsetY: boolean, duplicated_angle: boolean, duplicated_speed: boolean, duplicated_scale: boolean, duplicated_pinchCenterX: boolean, duplicated_pinchCenterY: boolean, duplicated_velocityX: boolean, duplicated_velocityY: boolean, duplicated_velocity: boolean): boolean {
+        if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else if ((!duplicated_fingerList) && (value?.hasOwnProperty("fingerList"))) {
+            return true
+        }
+        else if ((!duplicated_offsetX) && (value?.hasOwnProperty("offsetX"))) {
+            return true
+        }
+        else if ((!duplicated_offsetY) && (value?.hasOwnProperty("offsetY"))) {
+            return true
+        }
+        else if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else if ((!duplicated_speed) && (value?.hasOwnProperty("speed"))) {
+            return true
+        }
+        else if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_pinchCenterX) && (value?.hasOwnProperty("pinchCenterX"))) {
+            return true
+        }
+        else if ((!duplicated_pinchCenterY) && (value?.hasOwnProperty("pinchCenterY"))) {
+            return true
+        }
+        else if ((!duplicated_velocityX) && (value?.hasOwnProperty("velocityX"))) {
+            return true
+        }
+        else if ((!duplicated_velocityY) && (value?.hasOwnProperty("velocityY"))) {
+            return true
+        }
+        else if ((!duplicated_velocity) && (value?.hasOwnProperty("velocity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureEvent")
+        }
+    }
+    static isGestureGroupInterface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof GestureGroupInterface")
+    }
+    static isGestureInfo(value: Object | string | number | undefined | boolean, duplicated_tag: boolean, duplicated_type: boolean, duplicated_isSystemGesture: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_isSystemGesture) && (value?.hasOwnProperty("isSystemGesture"))) {
+            return true
+        }
+        else if ((!duplicated_tag) && (value?.hasOwnProperty("tag"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureInfo")
+        }
+    }
+    static isGestureJudgeResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GestureJudgeResult.CONTINUE)) {
+            return true
+        }
+        else if ((value) === (GestureJudgeResult.REJECT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureJudgeResult")
+        }
+    }
+    static isGestureMask(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GestureMask.Normal)) {
+            return true
+        }
+        else if ((value) === (GestureMask.IgnoreInternal)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureMask")
+        }
+    }
+    static isGestureMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GestureMode.Sequence)) {
+            return true
+        }
+        else if ((value) === (GestureMode.Parallel)) {
+            return true
+        }
+        else if ((value) === (GestureMode.Exclusive)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureMode")
+        }
+    }
+    static isGestureModifier(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof GestureModifier")
+    }
+    static isGesturePriority(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GesturePriority.NORMAL)) {
+            return true
+        }
+        else if ((value) === (GesturePriority.PRIORITY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GesturePriority")
+        }
+    }
+    static isGestureRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof GestureRecognizer")
+    }
+    static isGestureRecognizerState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GestureRecognizerState.READY)) {
+            return true
+        }
+        else if ((value) === (GestureRecognizerState.DETECTING)) {
+            return true
+        }
+        else if ((value) === (GestureRecognizerState.PENDING)) {
+            return true
+        }
+        else if ((value) === (GestureRecognizerState.BLOCKED)) {
+            return true
+        }
+        else if ((value) === (GestureRecognizerState.SUCCESSFUL)) {
+            return true
+        }
+        else if ((value) === (GestureRecognizerState.FAILED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureRecognizerState")
+        }
+    }
+    static isGestureStyle(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof GestureStyle")
+    }
+    static isGestureStyleInterface(value: Object | string | number | undefined | boolean, duplicated_onClick: boolean, duplicated_onLongPress: boolean): boolean {
+        if ((!duplicated_onClick) && (value?.hasOwnProperty("onClick"))) {
+            return true
+        }
+        else if ((!duplicated_onLongPress) && (value?.hasOwnProperty("onLongPress"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GestureStyleInterface")
+        }
+    }
+    static isGradientDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GradientDirection.Left)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.Top)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.Right)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.Bottom)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.LeftTop)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.LeftBottom)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.RightTop)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.RightBottom)) {
+            return true
+        }
+        else if ((value) === (GradientDirection.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GradientDirection")
+        }
+    }
+    static isGridColColumnOption(value: Object | string | number | undefined | boolean, duplicated_xs: boolean, duplicated_sm: boolean, duplicated_md: boolean, duplicated_lg: boolean, duplicated_xl: boolean, duplicated_xxl: boolean): boolean {
+        if ((!duplicated_xs) && (value?.hasOwnProperty("xs"))) {
+            return true
+        }
+        else if ((!duplicated_sm) && (value?.hasOwnProperty("sm"))) {
+            return true
+        }
+        else if ((!duplicated_md) && (value?.hasOwnProperty("md"))) {
+            return true
+        }
+        else if ((!duplicated_lg) && (value?.hasOwnProperty("lg"))) {
+            return true
+        }
+        else if ((!duplicated_xl) && (value?.hasOwnProperty("xl"))) {
+            return true
+        }
+        else if ((!duplicated_xxl) && (value?.hasOwnProperty("xxl"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridColColumnOption")
+        }
+    }
+    static isGridColOptions(value: Object | string | number | undefined | boolean, duplicated_span: boolean, duplicated_offset: boolean, duplicated_order: boolean): boolean {
+        if ((!duplicated_span) && (value?.hasOwnProperty("span"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_order) && (value?.hasOwnProperty("order"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridColOptions")
+        }
+    }
+    static isGridDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GridDirection.Row)) {
+            return true
+        }
+        else if ((value) === (GridDirection.Column)) {
+            return true
+        }
+        else if ((value) === (GridDirection.RowReverse)) {
+            return true
+        }
+        else if ((value) === (GridDirection.ColumnReverse)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridDirection")
+        }
+    }
+    static isGridItemAlignment(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GridItemAlignment.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (GridItemAlignment.STRETCH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridItemAlignment")
+        }
+    }
+    static isGridItemOptions(value: Object | string | number | undefined | boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridItemOptions")
+        }
+    }
+    static isGridItemStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GridItemStyle.NONE)) {
+            return true
+        }
+        else if ((value) === (GridItemStyle.PLAIN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridItemStyle")
+        }
+    }
+    static isGridLayoutOptions(value: Object | string | number | undefined | boolean, duplicated_regularSize: boolean, duplicated_irregularIndexes: boolean, duplicated_onGetIrregularSizeByIndex: boolean, duplicated_onGetRectByIndex: boolean): boolean {
+        if ((!duplicated_regularSize) && (value?.hasOwnProperty("regularSize"))) {
+            return true
+        }
+        else if ((!duplicated_irregularIndexes) && (value?.hasOwnProperty("irregularIndexes"))) {
+            return true
+        }
+        else if ((!duplicated_onGetIrregularSizeByIndex) && (value?.hasOwnProperty("onGetIrregularSizeByIndex"))) {
+            return true
+        }
+        else if ((!duplicated_onGetRectByIndex) && (value?.hasOwnProperty("onGetRectByIndex"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridLayoutOptions")
+        }
+    }
+    static isGridRowColumnOption(value: Object | string | number | undefined | boolean, duplicated_xs: boolean, duplicated_sm: boolean, duplicated_md: boolean, duplicated_lg: boolean, duplicated_xl: boolean, duplicated_xxl: boolean): boolean {
+        if ((!duplicated_xs) && (value?.hasOwnProperty("xs"))) {
+            return true
+        }
+        else if ((!duplicated_sm) && (value?.hasOwnProperty("sm"))) {
+            return true
+        }
+        else if ((!duplicated_md) && (value?.hasOwnProperty("md"))) {
+            return true
+        }
+        else if ((!duplicated_lg) && (value?.hasOwnProperty("lg"))) {
+            return true
+        }
+        else if ((!duplicated_xl) && (value?.hasOwnProperty("xl"))) {
+            return true
+        }
+        else if ((!duplicated_xxl) && (value?.hasOwnProperty("xxl"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridRowColumnOption")
+        }
+    }
+    static isGridRowDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (GridRowDirection.Row)) {
+            return true
+        }
+        else if ((value) === (GridRowDirection.RowReverse)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridRowDirection")
+        }
+    }
+    static isGridRowOptions(value: Object | string | number | undefined | boolean, duplicated_gutter: boolean, duplicated_columns: boolean, duplicated_breakpoints: boolean, duplicated_direction: boolean): boolean {
+        if ((!duplicated_gutter) && (value?.hasOwnProperty("gutter"))) {
+            return true
+        }
+        else if ((!duplicated_columns) && (value?.hasOwnProperty("columns"))) {
+            return true
+        }
+        else if ((!duplicated_breakpoints) && (value?.hasOwnProperty("breakpoints"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridRowOptions")
+        }
+    }
+    static isGridRowSizeOption(value: Object | string | number | undefined | boolean, duplicated_xs: boolean, duplicated_sm: boolean, duplicated_md: boolean, duplicated_lg: boolean, duplicated_xl: boolean, duplicated_xxl: boolean): boolean {
+        if ((!duplicated_xs) && (value?.hasOwnProperty("xs"))) {
+            return true
+        }
+        else if ((!duplicated_sm) && (value?.hasOwnProperty("sm"))) {
+            return true
+        }
+        else if ((!duplicated_md) && (value?.hasOwnProperty("md"))) {
+            return true
+        }
+        else if ((!duplicated_lg) && (value?.hasOwnProperty("lg"))) {
+            return true
+        }
+        else if ((!duplicated_xl) && (value?.hasOwnProperty("xl"))) {
+            return true
+        }
+        else if ((!duplicated_xxl) && (value?.hasOwnProperty("xxl"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GridRowSizeOption")
+        }
+    }
+    static isGuideLinePosition(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GuideLinePosition")
+        }
+    }
+    static isGuideLineStyle(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_direction: boolean, duplicated_position: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GuideLineStyle")
+        }
+    }
+    static isGutterOption(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof GutterOption")
+        }
+    }
+    static isHapticFeedbackMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HapticFeedbackMode.DISABLED)) {
+            return true
+        }
+        else if ((value) === (HapticFeedbackMode.ENABLED)) {
+            return true
+        }
+        else if ((value) === (HapticFeedbackMode.AUTO)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HapticFeedbackMode")
+        }
+    }
+    static isHeader(value: Object | string | number | undefined | boolean, duplicated_headerKey: boolean, duplicated_headerValue: boolean): boolean {
+        if ((!duplicated_headerKey) && (value?.hasOwnProperty("headerKey"))) {
+            return true
+        }
+        else if ((!duplicated_headerValue) && (value?.hasOwnProperty("headerValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Header")
+        }
+    }
+    static isHeightBreakpoint(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HeightBreakpoint.HEIGHT_SM)) {
+            return true
+        }
+        else if ((value) === (HeightBreakpoint.HEIGHT_MD)) {
+            return true
+        }
+        else if ((value) === (HeightBreakpoint.HEIGHT_LG)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HeightBreakpoint")
+        }
+    }
+    static isHierarchicalSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_fillStyle: boolean): boolean {
+        if ((!duplicated_fillStyle) && (value?.hasOwnProperty("fillStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HierarchicalSymbolEffect")
+        }
+    }
+    static isHistoricalPoint(value: Object | string | number | undefined | boolean, duplicated_touchObject: boolean, duplicated_size: boolean, duplicated_force: boolean, duplicated_timestamp: boolean): boolean {
+        if ((!duplicated_touchObject) && (value?.hasOwnProperty("touchObject"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_force) && (value?.hasOwnProperty("force"))) {
+            return true
+        }
+        else if ((!duplicated_timestamp) && (value?.hasOwnProperty("timestamp"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HistoricalPoint")
+        }
+    }
+    static isHitTestMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HitTestMode.Default)) {
+            return true
+        }
+        else if ((value) === (HitTestMode.Block)) {
+            return true
+        }
+        else if ((value) === (HitTestMode.Transparent)) {
+            return true
+        }
+        else if ((value) === (HitTestMode.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HitTestMode")
+        }
+    }
+    static isHitTestType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HitTestType.EditText)) {
+            return true
+        }
+        else if ((value) === (HitTestType.Email)) {
+            return true
+        }
+        else if ((value) === (HitTestType.HttpAnchor)) {
+            return true
+        }
+        else if ((value) === (HitTestType.HttpAnchorImg)) {
+            return true
+        }
+        else if ((value) === (HitTestType.Img)) {
+            return true
+        }
+        else if ((value) === (HitTestType.Map)) {
+            return true
+        }
+        else if ((value) === (HitTestType.Phone)) {
+            return true
+        }
+        else if ((value) === (HitTestType.Unknown)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HitTestType")
+        }
+    }
+    static isHorizontalAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HorizontalAlign.Start)) {
+            return true
+        }
+        else if ((value) === (HorizontalAlign.Center)) {
+            return true
+        }
+        else if ((value) === (HorizontalAlign.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HorizontalAlign")
+        }
+    }
+    static isHoverEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HoverEffect.Auto)) {
+            return true
+        }
+        else if ((value) === (HoverEffect.Scale)) {
+            return true
+        }
+        else if ((value) === (HoverEffect.Highlight)) {
+            return true
+        }
+        else if ((value) === (HoverEffect.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HoverEffect")
+        }
+    }
+    static isHoverEvent(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_stopPropagation: boolean): boolean {
+        if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HoverEvent")
+        }
+    }
+    static isHoverEventParam(value: Object | string | number | undefined | boolean, duplicated_foldStatus: boolean, duplicated_isHoverMode: boolean, duplicated_appRotation: boolean, duplicated_windowStatusType: boolean): boolean {
+        if ((!duplicated_foldStatus) && (value?.hasOwnProperty("foldStatus"))) {
+            return true
+        }
+        else if ((!duplicated_isHoverMode) && (value?.hasOwnProperty("isHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_appRotation) && (value?.hasOwnProperty("appRotation"))) {
+            return true
+        }
+        else if ((!duplicated_windowStatusType) && (value?.hasOwnProperty("windowStatusType"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HoverEventParam")
+        }
+    }
+    static isHoverModeAreaType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (HoverModeAreaType.TOP_SCREEN)) {
+            return true
+        }
+        else if ((value) === (HoverModeAreaType.BOTTOM_SCREEN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof HoverModeAreaType")
+        }
+    }
+    static isHttpAuthHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof HttpAuthHandler")
+    }
+    static isIconOptions(value: Object | string | number | undefined | boolean, duplicated_size: boolean, duplicated_color: boolean, duplicated_src: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof IconOptions")
+        }
+    }
+    static isIlluminatedType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (IlluminatedType.NONE)) {
+            return true
+        }
+        else if ((value) === (IlluminatedType.BORDER)) {
+            return true
+        }
+        else if ((value) === (IlluminatedType.CONTENT)) {
+            return true
+        }
+        else if ((value) === (IlluminatedType.BORDER_CONTENT)) {
+            return true
+        }
+        else if ((value) === (IlluminatedType.BLOOM_BORDER)) {
+            return true
+        }
+        else if ((value) === (IlluminatedType.BLOOM_BORDER_CONTENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof IlluminatedType")
+        }
+    }
+    static isimage_PixelMap(value: Object | string | number | undefined | boolean, duplicated_isEditable: boolean, duplicated_isStrideAlignment: boolean): boolean {
+        if ((!duplicated_isEditable) && (value?.hasOwnProperty("isEditable"))) {
+            return true
+        }
+        else if ((!duplicated_isStrideAlignment) && (value?.hasOwnProperty("isStrideAlignment"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof image.PixelMap")
+        }
+    }
+    static isimage_ResolutionQuality(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (image.ResolutionQuality.LOW)) {
+            return true
+        }
+        else if ((value) === (image.ResolutionQuality.MEDIUM)) {
+            return true
+        }
+        else if ((value) === (image.ResolutionQuality.HIGH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof image.ResolutionQuality")
+        }
+    }
+    static isImageAIOptions(value: Object | string | number | undefined | boolean, duplicated_types: boolean, duplicated_aiController: boolean): boolean {
+        if ((!duplicated_types) && (value?.hasOwnProperty("types"))) {
+            return true
+        }
+        else if ((!duplicated_aiController) && (value?.hasOwnProperty("aiController"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAIOptions")
+        }
+    }
+    static isImageAnalyzerConfig(value: Object | string | number | undefined | boolean, duplicated_types: boolean): boolean {
+        if ((!duplicated_types) && (value?.hasOwnProperty("types"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAnalyzerConfig")
+        }
+    }
+    static isImageAnalyzerController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ImageAnalyzerController")
+    }
+    static isImageAnalyzerType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageAnalyzerType.SUBJECT)) {
+            return true
+        }
+        else if ((value) === (ImageAnalyzerType.TEXT)) {
+            return true
+        }
+        else if ((value) === (ImageAnalyzerType.OBJECT_LOOKUP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAnalyzerType")
+        }
+    }
+    static isImageAttachment(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_size: boolean, duplicated_verticalAlign: boolean, duplicated_objectFit: boolean, duplicated_layoutStyle: boolean, duplicated_colorFilter: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_verticalAlign) && (value?.hasOwnProperty("verticalAlign"))) {
+            return true
+        }
+        else if ((!duplicated_objectFit) && (value?.hasOwnProperty("objectFit"))) {
+            return true
+        }
+        else if ((!duplicated_layoutStyle) && (value?.hasOwnProperty("layoutStyle"))) {
+            return true
+        }
+        else if ((!duplicated_colorFilter) && (value?.hasOwnProperty("colorFilter"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAttachment")
+        }
+    }
+    static isImageAttachmentInterface(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_size: boolean, duplicated_verticalAlign: boolean, duplicated_objectFit: boolean, duplicated_layoutStyle: boolean, duplicated_colorFilter: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_verticalAlign) && (value?.hasOwnProperty("verticalAlign"))) {
+            return true
+        }
+        else if ((!duplicated_objectFit) && (value?.hasOwnProperty("objectFit"))) {
+            return true
+        }
+        else if ((!duplicated_layoutStyle) && (value?.hasOwnProperty("layoutStyle"))) {
+            return true
+        }
+        else if ((!duplicated_colorFilter) && (value?.hasOwnProperty("colorFilter"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAttachmentInterface")
+        }
+    }
+    static isImageAttachmentLayoutStyle(value: Object | string | number | undefined | boolean, duplicated_margin: boolean, duplicated_padding: boolean, duplicated_borderRadius: boolean): boolean {
+        if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_padding) && (value?.hasOwnProperty("padding"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageAttachmentLayoutStyle")
+        }
+    }
+    static isImageBitmap(value: Object | string | number | undefined | boolean, duplicated_height: boolean, duplicated_width: boolean): boolean {
+        if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageBitmap")
+        }
+    }
+    static isImageCompleteEvent(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_componentWidth: boolean, duplicated_componentHeight: boolean, duplicated_loadingStatus: boolean, duplicated_contentWidth: boolean, duplicated_contentHeight: boolean, duplicated_contentOffsetX: boolean, duplicated_contentOffsetY: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_componentWidth) && (value?.hasOwnProperty("componentWidth"))) {
+            return true
+        }
+        else if ((!duplicated_componentHeight) && (value?.hasOwnProperty("componentHeight"))) {
+            return true
+        }
+        else if ((!duplicated_loadingStatus) && (value?.hasOwnProperty("loadingStatus"))) {
+            return true
+        }
+        else if ((!duplicated_contentWidth) && (value?.hasOwnProperty("contentWidth"))) {
+            return true
+        }
+        else if ((!duplicated_contentHeight) && (value?.hasOwnProperty("contentHeight"))) {
+            return true
+        }
+        else if ((!duplicated_contentOffsetX) && (value?.hasOwnProperty("contentOffsetX"))) {
+            return true
+        }
+        else if ((!duplicated_contentOffsetY) && (value?.hasOwnProperty("contentOffsetY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageCompleteEvent")
+        }
+    }
+    static isImageContent(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageContent.EMPTY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageContent")
+        }
+    }
+    static isImageData(value: Object | string | number | undefined | boolean, duplicated_data: boolean, duplicated_height: boolean, duplicated_width: boolean): boolean {
+        if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageData")
+        }
+    }
+    static isImageError(value: Object | string | number | undefined | boolean, duplicated_componentWidth: boolean, duplicated_componentHeight: boolean, duplicated_message: boolean, duplicated_error: boolean): boolean {
+        if ((!duplicated_componentWidth) && (value?.hasOwnProperty("componentWidth"))) {
+            return true
+        }
+        else if ((!duplicated_componentHeight) && (value?.hasOwnProperty("componentHeight"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageError")
+        }
+    }
+    static isImageFit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageFit.Contain)) {
+            return true
+        }
+        else if ((value) === (ImageFit.Cover)) {
+            return true
+        }
+        else if ((value) === (ImageFit.Auto)) {
+            return true
+        }
+        else if ((value) === (ImageFit.Fill)) {
+            return true
+        }
+        else if ((value) === (ImageFit.ScaleDown)) {
+            return true
+        }
+        else if ((value) === (ImageFit.None)) {
+            return true
+        }
+        else if ((value) === (ImageFit.TOP_START)) {
+            return true
+        }
+        else if ((value) === (ImageFit.TOP)) {
+            return true
+        }
+        else if ((value) === (ImageFit.TOP_END)) {
+            return true
+        }
+        else if ((value) === (ImageFit.START)) {
+            return true
+        }
+        else if ((value) === (ImageFit.CENTER)) {
+            return true
+        }
+        else if ((value) === (ImageFit.END)) {
+            return true
+        }
+        else if ((value) === (ImageFit.BOTTOM_START)) {
+            return true
+        }
+        else if ((value) === (ImageFit.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (ImageFit.BOTTOM_END)) {
+            return true
+        }
+        else if ((value) === (ImageFit.MATRIX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageFit")
+        }
+    }
+    static isImageFrameInfo(value: Object | string | number | undefined | boolean, duplicated_src: boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_top: boolean, duplicated_left: boolean, duplicated_duration: boolean): boolean {
+        if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageFrameInfo")
+        }
+    }
+    static isImageInterpolation(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageInterpolation.None)) {
+            return true
+        }
+        else if ((value) === (ImageInterpolation.Low)) {
+            return true
+        }
+        else if ((value) === (ImageInterpolation.Medium)) {
+            return true
+        }
+        else if ((value) === (ImageInterpolation.High)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageInterpolation")
+        }
+    }
+    static isImageLoadResult(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_componentWidth: boolean, duplicated_componentHeight: boolean, duplicated_loadingStatus: boolean, duplicated_contentWidth: boolean, duplicated_contentHeight: boolean, duplicated_contentOffsetX: boolean, duplicated_contentOffsetY: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_componentWidth) && (value?.hasOwnProperty("componentWidth"))) {
+            return true
+        }
+        else if ((!duplicated_componentHeight) && (value?.hasOwnProperty("componentHeight"))) {
+            return true
+        }
+        else if ((!duplicated_loadingStatus) && (value?.hasOwnProperty("loadingStatus"))) {
+            return true
+        }
+        else if ((!duplicated_contentWidth) && (value?.hasOwnProperty("contentWidth"))) {
+            return true
+        }
+        else if ((!duplicated_contentHeight) && (value?.hasOwnProperty("contentHeight"))) {
+            return true
+        }
+        else if ((!duplicated_contentOffsetX) && (value?.hasOwnProperty("contentOffsetX"))) {
+            return true
+        }
+        else if ((!duplicated_contentOffsetY) && (value?.hasOwnProperty("contentOffsetY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageLoadResult")
+        }
+    }
+    static isImageRenderMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageRenderMode.Original)) {
+            return true
+        }
+        else if ((value) === (ImageRenderMode.Template)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageRenderMode")
+        }
+    }
+    static isImageRepeat(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageRepeat.NoRepeat)) {
+            return true
+        }
+        else if ((value) === (ImageRepeat.X)) {
+            return true
+        }
+        else if ((value) === (ImageRepeat.Y)) {
+            return true
+        }
+        else if ((value) === (ImageRepeat.XY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageRepeat")
+        }
+    }
+    static isImageRotateOrientation(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageRotateOrientation.AUTO)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.UP)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.RIGHT)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.DOWN)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.LEFT)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.UP_MIRRORED)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.RIGHT_MIRRORED)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.DOWN_MIRRORED)) {
+            return true
+        }
+        else if ((value) === (ImageRotateOrientation.LEFT_MIRRORED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageRotateOrientation")
+        }
+    }
+    static isImageSize(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageSize.Auto)) {
+            return true
+        }
+        else if ((value) === (ImageSize.Cover)) {
+            return true
+        }
+        else if ((value) === (ImageSize.Contain)) {
+            return true
+        }
+        else if ((value) === (ImageSize.FILL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageSize")
+        }
+    }
+    static isImageSourceSize(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageSourceSize")
+        }
+    }
+    static isImageSpanAlignment(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImageSpanAlignment.BASELINE)) {
+            return true
+        }
+        else if ((value) === (ImageSpanAlignment.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (ImageSpanAlignment.CENTER)) {
+            return true
+        }
+        else if ((value) === (ImageSpanAlignment.TOP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImageSpanAlignment")
+        }
+    }
+    static isImmersiveMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ImmersiveMode.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (ImmersiveMode.EXTEND)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ImmersiveMode")
+        }
+    }
+    static isIndexerAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (IndexerAlign.Left)) {
+            return true
+        }
+        else if ((value) === (IndexerAlign.Right)) {
+            return true
+        }
+        else if ((value) === (IndexerAlign.START)) {
+            return true
+        }
+        else if ((value) === (IndexerAlign.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof IndexerAlign")
+        }
+    }
+    static isIndicatorComponentController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof IndicatorComponentController")
+    }
+    static isInputCounterOptions(value: Object | string | number | undefined | boolean, duplicated_thresholdPercentage: boolean, duplicated_highlightBorder: boolean): boolean {
+        if ((!duplicated_thresholdPercentage) && (value?.hasOwnProperty("thresholdPercentage"))) {
+            return true
+        }
+        else if ((!duplicated_highlightBorder) && (value?.hasOwnProperty("highlightBorder"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof InputCounterOptions")
+        }
+    }
+    static isInputType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (InputType.Normal)) {
+            return true
+        }
+        else if ((value) === (InputType.Number)) {
+            return true
+        }
+        else if ((value) === (InputType.PhoneNumber)) {
+            return true
+        }
+        else if ((value) === (InputType.Email)) {
+            return true
+        }
+        else if ((value) === (InputType.Password)) {
+            return true
+        }
+        else if ((value) === (InputType.NUMBER_PASSWORD)) {
+            return true
+        }
+        else if ((value) === (InputType.SCREEN_LOCK_PASSWORD)) {
+            return true
+        }
+        else if ((value) === (InputType.USER_NAME)) {
+            return true
+        }
+        else if ((value) === (InputType.NEW_PASSWORD)) {
+            return true
+        }
+        else if ((value) === (InputType.NUMBER_DECIMAL)) {
+            return true
+        }
+        else if ((value) === (InputType.URL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof InputType")
+        }
+    }
+    static isInsertValue(value: Object | string | number | undefined | boolean, duplicated_insertOffset: boolean, duplicated_insertValue: boolean): boolean {
+        if ((!duplicated_insertOffset) && (value?.hasOwnProperty("insertOffset"))) {
+            return true
+        }
+        else if ((!duplicated_insertValue) && (value?.hasOwnProperty("insertValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof InsertValue")
+        }
+    }
+    static isIntelligentTrackingPreventionDetails(value: Object | string | number | undefined | boolean, duplicated_host: boolean, duplicated_trackerHost: boolean): boolean {
+        if ((!duplicated_host) && (value?.hasOwnProperty("host"))) {
+            return true
+        }
+        else if ((!duplicated_trackerHost) && (value?.hasOwnProperty("trackerHost"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof IntelligentTrackingPreventionDetails")
+        }
+    }
+    static isIntentionCode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (IntentionCode.INTENTION_UNKNOWN)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_UP)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_DOWN)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_LEFT)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_RIGHT)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_SELECT)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_ESCAPE)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_BACK)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_FORWARD)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_MENU)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_PAGE_UP)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_PAGE_DOWN)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_ZOOM_OUT)) {
+            return true
+        }
+        else if ((value) === (IntentionCode.INTENTION_ZOOM_IN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof IntentionCode")
+        }
+    }
+    static isInteractionHand(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (InteractionHand.NONE)) {
+            return true
+        }
+        else if ((value) === (InteractionHand.LEFT)) {
+            return true
+        }
+        else if ((value) === (InteractionHand.RIGHT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof InteractionHand")
+        }
+    }
+    static isintl_DateTimeOptions(value: Object | string | number | undefined | boolean, duplicated_locale: boolean, duplicated_dateStyle: boolean, duplicated_timeStyle: boolean, duplicated_hourCycle: boolean, duplicated_timeZone: boolean, duplicated_numberingSystem: boolean, duplicated_hour12: boolean, duplicated_weekday: boolean, duplicated_era: boolean, duplicated_year: boolean, duplicated_month: boolean, duplicated_day: boolean, duplicated_hour: boolean, duplicated_minute: boolean, duplicated_second: boolean, duplicated_timeZoneName: boolean, duplicated_dayPeriod: boolean, duplicated_localeMatcher: boolean, duplicated_formatMatcher: boolean): boolean {
+        if ((!duplicated_locale) && (value?.hasOwnProperty("locale"))) {
+            return true
+        }
+        else if ((!duplicated_dateStyle) && (value?.hasOwnProperty("dateStyle"))) {
+            return true
+        }
+        else if ((!duplicated_timeStyle) && (value?.hasOwnProperty("timeStyle"))) {
+            return true
+        }
+        else if ((!duplicated_hourCycle) && (value?.hasOwnProperty("hourCycle"))) {
+            return true
+        }
+        else if ((!duplicated_timeZone) && (value?.hasOwnProperty("timeZone"))) {
+            return true
+        }
+        else if ((!duplicated_numberingSystem) && (value?.hasOwnProperty("numberingSystem"))) {
+            return true
+        }
+        else if ((!duplicated_hour12) && (value?.hasOwnProperty("hour12"))) {
+            return true
+        }
+        else if ((!duplicated_weekday) && (value?.hasOwnProperty("weekday"))) {
+            return true
+        }
+        else if ((!duplicated_era) && (value?.hasOwnProperty("era"))) {
+            return true
+        }
+        else if ((!duplicated_year) && (value?.hasOwnProperty("year"))) {
+            return true
+        }
+        else if ((!duplicated_month) && (value?.hasOwnProperty("month"))) {
+            return true
+        }
+        else if ((!duplicated_day) && (value?.hasOwnProperty("day"))) {
+            return true
+        }
+        else if ((!duplicated_hour) && (value?.hasOwnProperty("hour"))) {
+            return true
+        }
+        else if ((!duplicated_minute) && (value?.hasOwnProperty("minute"))) {
+            return true
+        }
+        else if ((!duplicated_second) && (value?.hasOwnProperty("second"))) {
+            return true
+        }
+        else if ((!duplicated_timeZoneName) && (value?.hasOwnProperty("timeZoneName"))) {
+            return true
+        }
+        else if ((!duplicated_dayPeriod) && (value?.hasOwnProperty("dayPeriod"))) {
+            return true
+        }
+        else if ((!duplicated_localeMatcher) && (value?.hasOwnProperty("localeMatcher"))) {
+            return true
+        }
+        else if ((!duplicated_formatMatcher) && (value?.hasOwnProperty("formatMatcher"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof intl.DateTimeOptions")
+        }
+    }
+    static isInvertOptions(value: Object | string | number | undefined | boolean, duplicated_low: boolean, duplicated_high: boolean, duplicated_threshold: boolean, duplicated_thresholdRange: boolean): boolean {
+        if ((!duplicated_low) && (value?.hasOwnProperty("low"))) {
+            return true
+        }
+        else if ((!duplicated_high) && (value?.hasOwnProperty("high"))) {
+            return true
+        }
+        else if ((!duplicated_threshold) && (value?.hasOwnProperty("threshold"))) {
+            return true
+        }
+        else if ((!duplicated_thresholdRange) && (value?.hasOwnProperty("thresholdRange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof InvertOptions")
+        }
+    }
+    static isItemAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ItemAlign.Auto)) {
+            return true
+        }
+        else if ((value) === (ItemAlign.Start)) {
+            return true
+        }
+        else if ((value) === (ItemAlign.Center)) {
+            return true
+        }
+        else if ((value) === (ItemAlign.End)) {
+            return true
+        }
+        else if ((value) === (ItemAlign.Baseline)) {
+            return true
+        }
+        else if ((value) === (ItemAlign.Stretch)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ItemAlign")
+        }
+    }
+    static isItemDragInfo(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ItemDragInfo")
+        }
+    }
+    static isItemState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ItemState.Normal)) {
+            return true
+        }
+        else if ((value) === (ItemState.Disabled)) {
+            return true
+        }
+        else if ((value) === (ItemState.Waiting)) {
+            return true
+        }
+        else if ((value) === (ItemState.Skip)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ItemState")
+        }
+    }
+    static isJavaScriptProxy(value: Object | string | number | undefined | boolean, duplicated_object_: boolean, duplicated_name: boolean, duplicated_methodList: boolean, duplicated_controller: boolean, duplicated_asyncMethodList: boolean, duplicated_permission: boolean): boolean {
+        if ((!duplicated_object_) && (value?.hasOwnProperty("object_"))) {
+            return true
+        }
+        else if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_methodList) && (value?.hasOwnProperty("methodList"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else if ((!duplicated_asyncMethodList) && (value?.hasOwnProperty("asyncMethodList"))) {
+            return true
+        }
+        else if ((!duplicated_permission) && (value?.hasOwnProperty("permission"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof JavaScriptProxy")
+        }
+    }
+    static isJsGeolocation(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof JsGeolocation")
+    }
+    static isJsResult(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof JsResult")
+    }
+    static isKeyboardAppearance(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (KeyboardAppearance.NONE_IMMERSIVE)) {
+            return true
+        }
+        else if ((value) === (KeyboardAppearance.IMMERSIVE)) {
+            return true
+        }
+        else if ((value) === (KeyboardAppearance.LIGHT_IMMERSIVE)) {
+            return true
+        }
+        else if ((value) === (KeyboardAppearance.DARK_IMMERSIVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyboardAppearance")
+        }
+    }
+    static isKeyboardAvoidMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (KeyboardAvoidMode.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (KeyboardAvoidMode.NONE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyboardAvoidMode")
+        }
+    }
+    static isKeyboardOptions(value: Object | string | number | undefined | boolean, duplicated_supportAvoidance: boolean): boolean {
+        if ((!duplicated_supportAvoidance) && (value?.hasOwnProperty("supportAvoidance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyboardOptions")
+        }
+    }
+    static isKeyEvent(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_keyCode: boolean, duplicated_keyText: boolean, duplicated_keySource: boolean, duplicated_deviceId: boolean, duplicated_metaKey: boolean, duplicated_timestamp: boolean, duplicated_stopPropagation: boolean, duplicated_intentionCode: boolean, duplicated_getModifierKeyState: boolean, duplicated_unicode: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_keyCode) && (value?.hasOwnProperty("keyCode"))) {
+            return true
+        }
+        else if ((!duplicated_keyText) && (value?.hasOwnProperty("keyText"))) {
+            return true
+        }
+        else if ((!duplicated_keySource) && (value?.hasOwnProperty("keySource"))) {
+            return true
+        }
+        else if ((!duplicated_deviceId) && (value?.hasOwnProperty("deviceId"))) {
+            return true
+        }
+        else if ((!duplicated_metaKey) && (value?.hasOwnProperty("metaKey"))) {
+            return true
+        }
+        else if ((!duplicated_timestamp) && (value?.hasOwnProperty("timestamp"))) {
+            return true
+        }
+        else if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else if ((!duplicated_intentionCode) && (value?.hasOwnProperty("intentionCode"))) {
+            return true
+        }
+        else if ((!duplicated_getModifierKeyState) && (value?.hasOwnProperty("getModifierKeyState"))) {
+            return true
+        }
+        else if ((!duplicated_unicode) && (value?.hasOwnProperty("unicode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyEvent")
+        }
+    }
+    static isKeyProcessingMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (KeyProcessingMode.FOCUS_NAVIGATION)) {
+            return true
+        }
+        else if ((value) === (KeyProcessingMode.ANCESTOR_EVENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyProcessingMode")
+        }
+    }
+    static isKeySource(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (KeySource.Unknown)) {
+            return true
+        }
+        else if ((value) === (KeySource.Keyboard)) {
+            return true
+        }
+        else if ((value) === (KeySource.JOYSTICK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeySource")
+        }
+    }
+    static isKeyType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (KeyType.Down)) {
+            return true
+        }
+        else if ((value) === (KeyType.Up)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof KeyType")
+        }
+    }
+    static isLargestContentfulPaint(value: Object | string | number | undefined | boolean, duplicated_navigationStartTime: boolean, duplicated_largestImagePaintTime: boolean, duplicated_largestTextPaintTime: boolean, duplicated_imageBPP: boolean, duplicated_largestImageLoadStartTime: boolean, duplicated_largestImageLoadEndTime: boolean): boolean {
+        if ((!duplicated_navigationStartTime) && (value?.hasOwnProperty("navigationStartTime"))) {
+            return true
+        }
+        else if ((!duplicated_largestImagePaintTime) && (value?.hasOwnProperty("largestImagePaintTime"))) {
+            return true
+        }
+        else if ((!duplicated_largestTextPaintTime) && (value?.hasOwnProperty("largestTextPaintTime"))) {
+            return true
+        }
+        else if ((!duplicated_imageBPP) && (value?.hasOwnProperty("imageBPP"))) {
+            return true
+        }
+        else if ((!duplicated_largestImageLoadStartTime) && (value?.hasOwnProperty("largestImageLoadStartTime"))) {
+            return true
+        }
+        else if ((!duplicated_largestImageLoadEndTime) && (value?.hasOwnProperty("largestImageLoadEndTime"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LargestContentfulPaint")
+        }
+    }
+    static isLaunchMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LaunchMode.STANDARD)) {
+            return true
+        }
+        else if ((value) === (LaunchMode.MOVE_TO_TOP_SINGLETON)) {
+            return true
+        }
+        else if ((value) === (LaunchMode.POP_TO_SINGLETON)) {
+            return true
+        }
+        else if ((value) === (LaunchMode.NEW_INSTANCE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LaunchMode")
+        }
+    }
+    static isLayoutable(value: Object | string | number | undefined | boolean, duplicated_measureResult: boolean, duplicated_uniqueId: boolean): boolean {
+        if ((!duplicated_measureResult) && (value?.hasOwnProperty("measureResult"))) {
+            return true
+        }
+        else if ((!duplicated_uniqueId) && (value?.hasOwnProperty("uniqueId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Layoutable")
+        }
+    }
+    static isLayoutCallback(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LayoutCallback")
+    }
+    static isLayoutChild(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_id: boolean, duplicated_position: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutChild")
+        }
+    }
+    static isLayoutConstraint(value: Object | string | number | undefined | boolean, duplicated_maxSize: boolean, duplicated_minSize: boolean, duplicated_percentReference: boolean): boolean {
+        if ((!duplicated_maxSize) && (value?.hasOwnProperty("maxSize"))) {
+            return true
+        }
+        else if ((!duplicated_minSize) && (value?.hasOwnProperty("minSize"))) {
+            return true
+        }
+        else if ((!duplicated_percentReference) && (value?.hasOwnProperty("percentReference"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutConstraint")
+        }
+    }
+    static isLayoutDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LayoutDirection.LTR)) {
+            return true
+        }
+        else if ((value) === (LayoutDirection.RTL)) {
+            return true
+        }
+        else if ((value) === (LayoutDirection.Auto)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutDirection")
+        }
+    }
+    static isLayoutManager(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LayoutManager")
+    }
+    static isLayoutMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LayoutMode.AUTO)) {
+            return true
+        }
+        else if ((value) === (LayoutMode.VERTICAL)) {
+            return true
+        }
+        else if ((value) === (LayoutMode.HORIZONTAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutMode")
+        }
+    }
+    static isLayoutPolicy(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LayoutPolicy")
+    }
+    static isLayoutSafeAreaEdge(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LayoutSafeAreaEdge.TOP)) {
+            return true
+        }
+        else if ((value) === (LayoutSafeAreaEdge.BOTTOM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutSafeAreaEdge")
+        }
+    }
+    static isLayoutSafeAreaType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LayoutSafeAreaType.SYSTEM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutSafeAreaType")
+        }
+    }
+    static isLayoutStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LayoutStyle.ALWAYS_CENTER)) {
+            return true
+        }
+        else if ((value) === (LayoutStyle.ALWAYS_AVERAGE_SPLIT)) {
+            return true
+        }
+        else if ((value) === (LayoutStyle.SPACE_BETWEEN_OR_CENTER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LayoutStyle")
+        }
+    }
+    static isLeadingMarginPlaceholder(value: Object | string | number | undefined | boolean, duplicated_pixelMap: boolean, duplicated_size: boolean): boolean {
+        if ((!duplicated_pixelMap) && (value?.hasOwnProperty("pixelMap"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LeadingMarginPlaceholder")
+        }
+    }
+    static isLengthConstrain(value: Object | string | number | undefined | boolean, duplicated_minLength: boolean, duplicated_maxLength: boolean): boolean {
+        if ((!duplicated_minLength) && (value?.hasOwnProperty("minLength"))) {
+            return true
+        }
+        else if ((!duplicated_maxLength) && (value?.hasOwnProperty("maxLength"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LengthConstrain")
+        }
+    }
+    static isLengthMetrics(value: Object | string | number | undefined | boolean, duplicated_unit: boolean, duplicated_value: boolean): boolean {
+        if ((!duplicated_unit) && (value?.hasOwnProperty("unit"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LengthMetrics")
+        }
+    }
+    static isLengthMetricsUnit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LengthMetricsUnit.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (LengthMetricsUnit.PX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LengthMetricsUnit")
+        }
+    }
+    static isLengthUnit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LengthUnit.PX)) {
+            return true
+        }
+        else if ((value) === (LengthUnit.VP)) {
+            return true
+        }
+        else if ((value) === (LengthUnit.FP)) {
+            return true
+        }
+        else if ((value) === (LengthUnit.PERCENT)) {
+            return true
+        }
+        else if ((value) === (LengthUnit.LPX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LengthUnit")
+        }
+    }
+    static isLetterSpacingStyle(value: Object | string | number | undefined | boolean, duplicated_letterSpacing: boolean): boolean {
+        if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LetterSpacingStyle")
+        }
+    }
+    static isLevelMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LevelMode.OVERLAY)) {
+            return true
+        }
+        else if ((value) === (LevelMode.EMBEDDED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LevelMode")
+        }
+    }
+    static isLevelOrder(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LevelOrder")
+    }
+    static isLifeCycle(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LifeCycle")
+    }
+    static isLightSource(value: Object | string | number | undefined | boolean, duplicated_positionX: boolean, duplicated_positionY: boolean, duplicated_positionZ: boolean, duplicated_intensity: boolean, duplicated_color: boolean): boolean {
+        if ((!duplicated_positionX) && (value?.hasOwnProperty("positionX"))) {
+            return true
+        }
+        else if ((!duplicated_positionY) && (value?.hasOwnProperty("positionY"))) {
+            return true
+        }
+        else if ((!duplicated_positionZ) && (value?.hasOwnProperty("positionZ"))) {
+            return true
+        }
+        else if ((!duplicated_intensity) && (value?.hasOwnProperty("intensity"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LightSource")
+        }
+    }
+    static isLinearGradient(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LinearGradient")
+    }
+    static isLinearGradientBlurOptions(value: Object | string | number | undefined | boolean, duplicated_fractionStops: boolean, duplicated_direction: boolean): boolean {
+        if ((!duplicated_fractionStops) && (value?.hasOwnProperty("fractionStops"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LinearGradientBlurOptions")
+        }
+    }
+    static isLinearGradientOptions(value: Object | string | number | undefined | boolean, duplicated_angle: boolean, duplicated_direction: boolean, duplicated_colors: boolean, duplicated_repeating: boolean): boolean {
+        if ((!duplicated_colors) && (value?.hasOwnProperty("colors"))) {
+            return true
+        }
+        else if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_repeating) && (value?.hasOwnProperty("repeating"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LinearGradientOptions")
+        }
+    }
+    static isLinearIndicatorController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LinearIndicatorController")
+    }
+    static isLinearIndicatorStartOptions(value: Object | string | number | undefined | boolean, duplicated_interval: boolean, duplicated_duration: boolean): boolean {
+        if ((!duplicated_interval) && (value?.hasOwnProperty("interval"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LinearIndicatorStartOptions")
+        }
+    }
+    static isLinearIndicatorStyle(value: Object | string | number | undefined | boolean, duplicated_space: boolean, duplicated_strokeWidth: boolean, duplicated_strokeRadius: boolean, duplicated_trackBackgroundColor: boolean, duplicated_trackColor: boolean): boolean {
+        if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_strokeRadius) && (value?.hasOwnProperty("strokeRadius"))) {
+            return true
+        }
+        else if ((!duplicated_trackBackgroundColor) && (value?.hasOwnProperty("trackBackgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_trackColor) && (value?.hasOwnProperty("trackColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LinearIndicatorStyle")
+        }
+    }
+    static isLinearStyleOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_strokeRadius: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_strokeRadius) && (value?.hasOwnProperty("strokeRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LinearStyleOptions")
+        }
+    }
+    static isLineBreakStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LineBreakStrategy.GREEDY)) {
+            return true
+        }
+        else if ((value) === (LineBreakStrategy.HIGH_QUALITY)) {
+            return true
+        }
+        else if ((value) === (LineBreakStrategy.BALANCED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LineBreakStrategy")
+        }
+    }
+    static isLineCapStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LineCapStyle.Butt)) {
+            return true
+        }
+        else if ((value) === (LineCapStyle.Round)) {
+            return true
+        }
+        else if ((value) === (LineCapStyle.Square)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LineCapStyle")
+        }
+    }
+    static isLineHeightStyle(value: Object | string | number | undefined | boolean, duplicated_lineHeight: boolean): boolean {
+        if ((!duplicated_lineHeight) && (value?.hasOwnProperty("lineHeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LineHeightStyle")
+        }
+    }
+    static isLineJoinStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LineJoinStyle.Miter)) {
+            return true
+        }
+        else if ((value) === (LineJoinStyle.Round)) {
+            return true
+        }
+        else if ((value) === (LineJoinStyle.Bevel)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LineJoinStyle")
+        }
+    }
+    static isLineOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LineOptions")
+    }
+    static isListDividerOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_color: boolean, duplicated_startMargin: boolean, duplicated_endMargin: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_startMargin) && (value?.hasOwnProperty("startMargin"))) {
+            return true
+        }
+        else if ((!duplicated_endMargin) && (value?.hasOwnProperty("endMargin"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListDividerOptions")
+        }
+    }
+    static isListItemAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ListItemAlign.Start)) {
+            return true
+        }
+        else if ((value) === (ListItemAlign.Center)) {
+            return true
+        }
+        else if ((value) === (ListItemAlign.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemAlign")
+        }
+    }
+    static isListItemGroupArea(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ListItemGroupArea.NONE)) {
+            return true
+        }
+        else if ((value) === (ListItemGroupArea.IN_LIST_ITEM_AREA)) {
+            return true
+        }
+        else if ((value) === (ListItemGroupArea.IN_HEADER_AREA)) {
+            return true
+        }
+        else if ((value) === (ListItemGroupArea.IN_FOOTER_AREA)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemGroupArea")
+        }
+    }
+    static isListItemGroupOptions(value: Object | string | number | undefined | boolean, duplicated_header: boolean, duplicated_headerComponent: boolean, duplicated_footer: boolean, duplicated_footerComponent: boolean, duplicated_space: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_header) && (value?.hasOwnProperty("header"))) {
+            return true
+        }
+        else if ((!duplicated_headerComponent) && (value?.hasOwnProperty("headerComponent"))) {
+            return true
+        }
+        else if ((!duplicated_footer) && (value?.hasOwnProperty("footer"))) {
+            return true
+        }
+        else if ((!duplicated_footerComponent) && (value?.hasOwnProperty("footerComponent"))) {
+            return true
+        }
+        else if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemGroupOptions")
+        }
+    }
+    static isListItemGroupStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ListItemGroupStyle.NONE)) {
+            return true
+        }
+        else if ((value) === (ListItemGroupStyle.CARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemGroupStyle")
+        }
+    }
+    static isListItemOptions(value: Object | string | number | undefined | boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemOptions")
+        }
+    }
+    static isListItemStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ListItemStyle.NONE)) {
+            return true
+        }
+        else if ((value) === (ListItemStyle.CARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListItemStyle")
+        }
+    }
+    static isListOptions(value: Object | string | number | undefined | boolean, duplicated_initialIndex: boolean, duplicated_space: boolean, duplicated_scroller: boolean): boolean {
+        if ((!duplicated_initialIndex) && (value?.hasOwnProperty("initialIndex"))) {
+            return true
+        }
+        else if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else if ((!duplicated_scroller) && (value?.hasOwnProperty("scroller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ListOptions")
+        }
+    }
+    static isListScroller(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ListScroller")
+    }
+    static isLoadCommittedDetails(value: Object | string | number | undefined | boolean, duplicated_isMainFrame: boolean, duplicated_isSameDocument: boolean, duplicated_didReplaceEntry: boolean, duplicated_navigationType: boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_isMainFrame) && (value?.hasOwnProperty("isMainFrame"))) {
+            return true
+        }
+        else if ((!duplicated_isSameDocument) && (value?.hasOwnProperty("isSameDocument"))) {
+            return true
+        }
+        else if ((!duplicated_didReplaceEntry) && (value?.hasOwnProperty("didReplaceEntry"))) {
+            return true
+        }
+        else if ((!duplicated_navigationType) && (value?.hasOwnProperty("navigationType"))) {
+            return true
+        }
+        else if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LoadCommittedDetails")
+        }
+    }
+    static isLoadingProgressConfiguration(value: Object | string | number | undefined | boolean, duplicated_enableLoading: boolean): boolean {
+        if ((!duplicated_enableLoading) && (value?.hasOwnProperty("enableLoading"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LoadingProgressConfiguration")
+        }
+    }
+    static isLoadingProgressStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LoadingProgressStyle.Default)) {
+            return true
+        }
+        else if ((value) === (LoadingProgressStyle.Circular)) {
+            return true
+        }
+        else if ((value) === (LoadingProgressStyle.Orbital)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LoadingProgressStyle")
+        }
+    }
+    static isLocalizedAlignRuleOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_middle: boolean, duplicated_top: boolean, duplicated_bottom: boolean, duplicated_center: boolean, duplicated_bias: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_middle) && (value?.hasOwnProperty("middle"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_center) && (value?.hasOwnProperty("center"))) {
+            return true
+        }
+        else if ((!duplicated_bias) && (value?.hasOwnProperty("bias"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedAlignRuleOptions")
+        }
+    }
+    static isLocalizedBarrierDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LocalizedBarrierDirection.START)) {
+            return true
+        }
+        else if ((value) === (LocalizedBarrierDirection.END)) {
+            return true
+        }
+        else if ((value) === (LocalizedBarrierDirection.TOP)) {
+            return true
+        }
+        else if ((value) === (LocalizedBarrierDirection.BOTTOM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedBarrierDirection")
+        }
+    }
+    static isLocalizedBorderRadiuses(value: Object | string | number | undefined | boolean, duplicated_topStart: boolean, duplicated_topEnd: boolean, duplicated_bottomStart: boolean, duplicated_bottomEnd: boolean): boolean {
+        if ((!duplicated_topStart) && (value?.hasOwnProperty("topStart"))) {
+            return true
+        }
+        else if ((!duplicated_topEnd) && (value?.hasOwnProperty("topEnd"))) {
+            return true
+        }
+        else if ((!duplicated_bottomStart) && (value?.hasOwnProperty("bottomStart"))) {
+            return true
+        }
+        else if ((!duplicated_bottomEnd) && (value?.hasOwnProperty("bottomEnd"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedBorderRadiuses")
+        }
+    }
+    static isLocalizedEdgeColors(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_end: boolean, duplicated_bottom: boolean, duplicated_start: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedEdgeColors")
+        }
+    }
+    static isLocalizedEdges(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_start: boolean, duplicated_bottom: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedEdges")
+        }
+    }
+    static isLocalizedEdgeWidths(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_end: boolean, duplicated_bottom: boolean, duplicated_start: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedEdgeWidths")
+        }
+    }
+    static isLocalizedHorizontalAlignParam(value: Object | string | number | undefined | boolean, duplicated_anchor: boolean, duplicated_align: boolean): boolean {
+        if ((!duplicated_anchor) && (value?.hasOwnProperty("anchor"))) {
+            return true
+        }
+        else if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedHorizontalAlignParam")
+        }
+    }
+    static isLocalizedPadding(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_end: boolean, duplicated_bottom: boolean, duplicated_start: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedPadding")
+        }
+    }
+    static isLocalizedPosition(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_top: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedPosition")
+        }
+    }
+    static isLocalizedVerticalAlignParam(value: Object | string | number | undefined | boolean, duplicated_anchor: boolean, duplicated_align: boolean): boolean {
+        if ((!duplicated_anchor) && (value?.hasOwnProperty("anchor"))) {
+            return true
+        }
+        else if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocalizedVerticalAlignParam")
+        }
+    }
+    static isLocationButtonOnClickResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LocationButtonOnClickResult.SUCCESS)) {
+            return true
+        }
+        else if ((value) === (LocationButtonOnClickResult.TEMPORARY_AUTHORIZATION_FAILED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocationButtonOnClickResult")
+        }
+    }
+    static isLocationDescription(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LocationDescription.CURRENT_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.ADD_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.SELECT_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.SHARE_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.SEND_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.LOCATING)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.SEND_CURRENT_LOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.RELOCATION)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.PUNCH_IN)) {
+            return true
+        }
+        else if ((value) === (LocationDescription.CURRENT_POSITION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocationDescription")
+        }
+    }
+    static isLocationIconStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (LocationIconStyle.FULL_FILLED)) {
+            return true
+        }
+        else if ((value) === (LocationIconStyle.LINES)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LocationIconStyle")
+        }
+    }
+    static isLongPressGestureEvent(value: Object | string | number | undefined | boolean, duplicated_repeat: boolean): boolean {
+        if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LongPressGestureEvent")
+        }
+    }
+    static isLongPressGestureHandlerOptions(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_repeat: boolean, duplicated_duration: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LongPressGestureHandlerOptions")
+        }
+    }
+    static isLongPressGestureInterface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LongPressGestureInterface")
+    }
+    static isLongPressGestureInterface_Invoke_Literal(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_repeat: boolean, duplicated_duration: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_repeat) && (value?.hasOwnProperty("repeat"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof LongPressGestureInterface_Invoke_Literal")
+        }
+    }
+    static isLongPressRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof LongPressRecognizer")
+    }
+    static isMarkStyle(value: Object | string | number | undefined | boolean, duplicated_strokeColor: boolean, duplicated_size: boolean, duplicated_strokeWidth: boolean): boolean {
+        if ((!duplicated_strokeColor) && (value?.hasOwnProperty("strokeColor"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MarkStyle")
+        }
+    }
+    static isMarqueeOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_step: boolean, duplicated_loop: boolean, duplicated_fromStart: boolean, duplicated_src: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_step) && (value?.hasOwnProperty("step"))) {
+            return true
+        }
+        else if ((!duplicated_loop) && (value?.hasOwnProperty("loop"))) {
+            return true
+        }
+        else if ((!duplicated_fromStart) && (value?.hasOwnProperty("fromStart"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MarqueeOptions")
+        }
+    }
+    static isMarqueeStartPolicy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MarqueeStartPolicy.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (MarqueeStartPolicy.ON_FOCUS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MarqueeStartPolicy")
+        }
+    }
+    static isMarqueeState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MarqueeState.START)) {
+            return true
+        }
+        else if ((value) === (MarqueeState.BOUNCE)) {
+            return true
+        }
+        else if ((value) === (MarqueeState.FINISH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MarqueeState")
+        }
+    }
+    static isMarqueeUpdateStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MarqueeUpdateStrategy.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (MarqueeUpdateStrategy.PRESERVE_POSITION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MarqueeUpdateStrategy")
+        }
+    }
+    static isMatrix2D(value: Object | string | number | undefined | boolean, duplicated_scaleX: boolean, duplicated_rotateY: boolean, duplicated_rotateX: boolean, duplicated_scaleY: boolean, duplicated_translateX: boolean, duplicated_translateY: boolean): boolean {
+        if ((!duplicated_scaleX) && (value?.hasOwnProperty("scaleX"))) {
+            return true
+        }
+        else if ((!duplicated_rotateY) && (value?.hasOwnProperty("rotateY"))) {
+            return true
+        }
+        else if ((!duplicated_rotateX) && (value?.hasOwnProperty("rotateX"))) {
+            return true
+        }
+        else if ((!duplicated_scaleY) && (value?.hasOwnProperty("scaleY"))) {
+            return true
+        }
+        else if ((!duplicated_translateX) && (value?.hasOwnProperty("translateX"))) {
+            return true
+        }
+        else if ((!duplicated_translateY) && (value?.hasOwnProperty("translateY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Matrix2D")
+        }
+    }
+    static ismatrix4_Matrix4Transit(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof matrix4.Matrix4Transit")
+    }
+    static ismatrix4_PolyToPolyOptions(value: Object | string | number | undefined | boolean, duplicated_src: boolean, duplicated_srcIndex: boolean, duplicated_dst: boolean, duplicated_dstIndex: boolean, duplicated_pointCount: boolean): boolean {
+        if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_dst) && (value?.hasOwnProperty("dst"))) {
+            return true
+        }
+        else if ((!duplicated_srcIndex) && (value?.hasOwnProperty("srcIndex"))) {
+            return true
+        }
+        else if ((!duplicated_dstIndex) && (value?.hasOwnProperty("dstIndex"))) {
+            return true
+        }
+        else if ((!duplicated_pointCount) && (value?.hasOwnProperty("pointCount"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof matrix4.PolyToPolyOptions")
+        }
+    }
+    static isMeasurable(value: Object | string | number | undefined | boolean, duplicated_uniqueId: boolean): boolean {
+        if ((!duplicated_uniqueId) && (value?.hasOwnProperty("uniqueId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Measurable")
+        }
+    }
+    static isMeasureOptions(value: Object | string | number | undefined | boolean, duplicated_textContent: boolean, duplicated_constraintWidth: boolean, duplicated_fontSize: boolean, duplicated_fontStyle: boolean, duplicated_fontWeight: boolean, duplicated_fontFamily: boolean, duplicated_letterSpacing: boolean, duplicated_textAlign: boolean, duplicated_overflow: boolean, duplicated_maxLines: boolean, duplicated_lineHeight: boolean, duplicated_baselineOffset: boolean, duplicated_textCase: boolean, duplicated_textIndent: boolean, duplicated_wordBreak: boolean): boolean {
+        if ((!duplicated_textContent) && (value?.hasOwnProperty("textContent"))) {
+            return true
+        }
+        else if ((!duplicated_constraintWidth) && (value?.hasOwnProperty("constraintWidth"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_textAlign) && (value?.hasOwnProperty("textAlign"))) {
+            return true
+        }
+        else if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_lineHeight) && (value?.hasOwnProperty("lineHeight"))) {
+            return true
+        }
+        else if ((!duplicated_baselineOffset) && (value?.hasOwnProperty("baselineOffset"))) {
+            return true
+        }
+        else if ((!duplicated_textCase) && (value?.hasOwnProperty("textCase"))) {
+            return true
+        }
+        else if ((!duplicated_textIndent) && (value?.hasOwnProperty("textIndent"))) {
+            return true
+        }
+        else if ((!duplicated_wordBreak) && (value?.hasOwnProperty("wordBreak"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MeasureOptions")
+        }
+    }
+    static isMeasureResult(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof MeasureResult")
+    }
+    static isMenuAlignType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MenuAlignType.START)) {
+            return true
+        }
+        else if ((value) === (MenuAlignType.CENTER)) {
+            return true
+        }
+        else if ((value) === (MenuAlignType.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuAlignType")
+        }
+    }
+    static isMenuElement(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_icon: boolean, duplicated_symbolIcon: boolean, duplicated_enabled: boolean, duplicated_action: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolIcon) && (value?.hasOwnProperty("symbolIcon"))) {
+            return true
+        }
+        else if ((!duplicated_enabled) && (value?.hasOwnProperty("enabled"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuElement")
+        }
+    }
+    static isMenuItemConfiguration(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_icon: boolean, duplicated_symbolIcon: boolean, duplicated_selected: boolean, duplicated_index: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolIcon) && (value?.hasOwnProperty("symbolIcon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuItemConfiguration")
+        }
+    }
+    static isMenuItemGroupOptions(value: Object | string | number | undefined | boolean, duplicated_header: boolean, duplicated_footer: boolean): boolean {
+        if ((!duplicated_header) && (value?.hasOwnProperty("header"))) {
+            return true
+        }
+        else if ((!duplicated_footer) && (value?.hasOwnProperty("footer"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuItemGroupOptions")
+        }
+    }
+    static isMenuItemOptions(value: Object | string | number | undefined | boolean, duplicated_startIcon: boolean, duplicated_symbolStartIcon: boolean, duplicated_content: boolean, duplicated_endIcon: boolean, duplicated_symbolEndIcon: boolean, duplicated_labelInfo: boolean, duplicated_builder: boolean): boolean {
+        if ((!duplicated_startIcon) && (value?.hasOwnProperty("startIcon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolStartIcon) && (value?.hasOwnProperty("symbolStartIcon"))) {
+            return true
+        }
+        else if ((!duplicated_content) && (value?.hasOwnProperty("content"))) {
+            return true
+        }
+        else if ((!duplicated_endIcon) && (value?.hasOwnProperty("endIcon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolEndIcon) && (value?.hasOwnProperty("symbolEndIcon"))) {
+            return true
+        }
+        else if ((!duplicated_labelInfo) && (value?.hasOwnProperty("labelInfo"))) {
+            return true
+        }
+        else if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuItemOptions")
+        }
+    }
+    static isMenuOptions(value: Object | string | number | undefined | boolean, duplicated_title: boolean, duplicated_showInSubWindow: boolean): boolean {
+        if ((!duplicated_title) && (value?.hasOwnProperty("title"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuOptions")
+        }
+    }
+    static isMenuOutlineOptions(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_color: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuOutlineOptions")
+        }
+    }
+    static isMenuPolicy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MenuPolicy.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (MenuPolicy.HIDE)) {
+            return true
+        }
+        else if ((value) === (MenuPolicy.SHOW)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuPolicy")
+        }
+    }
+    static isMenuPreviewMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MenuPreviewMode.NONE)) {
+            return true
+        }
+        else if ((value) === (MenuPreviewMode.IMAGE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuPreviewMode")
+        }
+    }
+    static isMenuType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MenuType.SELECTION_MENU)) {
+            return true
+        }
+        else if ((value) === (MenuType.PREVIEW_MENU)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MenuType")
+        }
+    }
+    static isMessageEvents(value: Object | string | number | undefined | boolean, duplicated_data: boolean): boolean {
+        if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MessageEvents")
+        }
+    }
+    static isMessageLevel(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MessageLevel.Debug)) {
+            return true
+        }
+        else if ((value) === (MessageLevel.Error)) {
+            return true
+        }
+        else if ((value) === (MessageLevel.Info)) {
+            return true
+        }
+        else if ((value) === (MessageLevel.Log)) {
+            return true
+        }
+        else if ((value) === (MessageLevel.Warn)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MessageLevel")
+        }
+    }
+    static isMixedMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MixedMode.All)) {
+            return true
+        }
+        else if ((value) === (MixedMode.Compatible)) {
+            return true
+        }
+        else if ((value) === (MixedMode.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MixedMode")
+        }
+    }
+    static isModalTransition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ModalTransition.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (ModalTransition.NONE)) {
+            return true
+        }
+        else if ((value) === (ModalTransition.ALPHA)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ModalTransition")
+        }
+    }
+    static isModifierKey(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ModifierKey.CTRL)) {
+            return true
+        }
+        else if ((value) === (ModifierKey.SHIFT)) {
+            return true
+        }
+        else if ((value) === (ModifierKey.ALT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ModifierKey")
+        }
+    }
+    static isMonthData(value: Object | string | number | undefined | boolean, duplicated_year: boolean, duplicated_month: boolean, duplicated_data: boolean): boolean {
+        if ((!duplicated_year) && (value?.hasOwnProperty("year"))) {
+            return true
+        }
+        else if ((!duplicated_month) && (value?.hasOwnProperty("month"))) {
+            return true
+        }
+        else if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MonthData")
+        }
+    }
+    static isMoreButtonOptions(value: Object | string | number | undefined | boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean): boolean {
+        if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MoreButtonOptions")
+        }
+    }
+    static isMotionBlurAnchor(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MotionBlurAnchor")
+        }
+    }
+    static isMotionBlurOptions(value: Object | string | number | undefined | boolean, duplicated_radius: boolean, duplicated_anchor: boolean): boolean {
+        if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_anchor) && (value?.hasOwnProperty("anchor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MotionBlurOptions")
+        }
+    }
+    static isMotionPathOptions(value: Object | string | number | undefined | boolean, duplicated_path: boolean, duplicated_from: boolean, duplicated_to: boolean, duplicated_rotatable: boolean): boolean {
+        if ((!duplicated_path) && (value?.hasOwnProperty("path"))) {
+            return true
+        }
+        else if ((!duplicated_from) && (value?.hasOwnProperty("from"))) {
+            return true
+        }
+        else if ((!duplicated_to) && (value?.hasOwnProperty("to"))) {
+            return true
+        }
+        else if ((!duplicated_rotatable) && (value?.hasOwnProperty("rotatable"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MotionPathOptions")
+        }
+    }
+    static isMouseAction(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MouseAction.Press)) {
+            return true
+        }
+        else if ((value) === (MouseAction.Release)) {
+            return true
+        }
+        else if ((value) === (MouseAction.Move)) {
+            return true
+        }
+        else if ((value) === (MouseAction.Hover)) {
+            return true
+        }
+        else if ((value) === (MouseAction.CANCEL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MouseAction")
+        }
+    }
+    static isMouseButton(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (MouseButton.Left)) {
+            return true
+        }
+        else if ((value) === (MouseButton.Right)) {
+            return true
+        }
+        else if ((value) === (MouseButton.Middle)) {
+            return true
+        }
+        else if ((value) === (MouseButton.Back)) {
+            return true
+        }
+        else if ((value) === (MouseButton.Forward)) {
+            return true
+        }
+        else if ((value) === (MouseButton.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MouseButton")
+        }
+    }
+    static isMouseEvent(value: Object | string | number | undefined | boolean, duplicated_button: boolean, duplicated_action: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_stopPropagation: boolean, duplicated_rawDeltaX: boolean, duplicated_rawDeltaY: boolean, duplicated_pressedButtons: boolean): boolean {
+        if ((!duplicated_button) && (value?.hasOwnProperty("button"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else if ((!duplicated_rawDeltaX) && (value?.hasOwnProperty("rawDeltaX"))) {
+            return true
+        }
+        else if ((!duplicated_rawDeltaY) && (value?.hasOwnProperty("rawDeltaY"))) {
+            return true
+        }
+        else if ((!duplicated_pressedButtons) && (value?.hasOwnProperty("pressedButtons"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof MouseEvent")
+        }
+    }
+    static isMutableStyledString(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof MutableStyledString")
+    }
+    static isNativeEmbedDataInfo(value: Object | string | number | undefined | boolean, duplicated_status: boolean, duplicated_surfaceId: boolean, duplicated_embedId: boolean, duplicated_info: boolean): boolean {
+        if ((!duplicated_status) && (value?.hasOwnProperty("status"))) {
+            return true
+        }
+        else if ((!duplicated_surfaceId) && (value?.hasOwnProperty("surfaceId"))) {
+            return true
+        }
+        else if ((!duplicated_embedId) && (value?.hasOwnProperty("embedId"))) {
+            return true
+        }
+        else if ((!duplicated_info) && (value?.hasOwnProperty("info"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeEmbedDataInfo")
+        }
+    }
+    static isNativeEmbedInfo(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_type: boolean, duplicated_src: boolean, duplicated_position: boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_url: boolean, duplicated_tag: boolean, duplicated_params: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_tag) && (value?.hasOwnProperty("tag"))) {
+            return true
+        }
+        else if ((!duplicated_params) && (value?.hasOwnProperty("params"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeEmbedInfo")
+        }
+    }
+    static isNativeEmbedStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NativeEmbedStatus.CREATE)) {
+            return true
+        }
+        else if ((value) === (NativeEmbedStatus.UPDATE)) {
+            return true
+        }
+        else if ((value) === (NativeEmbedStatus.DESTROY)) {
+            return true
+        }
+        else if ((value) === (NativeEmbedStatus.ENTER_BFCACHE)) {
+            return true
+        }
+        else if ((value) === (NativeEmbedStatus.LEAVE_BFCACHE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeEmbedStatus")
+        }
+    }
+    static isNativeEmbedTouchInfo(value: Object | string | number | undefined | boolean, duplicated_embedId: boolean, duplicated_touchEvent: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_embedId) && (value?.hasOwnProperty("embedId"))) {
+            return true
+        }
+        else if ((!duplicated_touchEvent) && (value?.hasOwnProperty("touchEvent"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeEmbedTouchInfo")
+        }
+    }
+    static isNativeEmbedVisibilityInfo(value: Object | string | number | undefined | boolean, duplicated_visibility: boolean, duplicated_embedId: boolean): boolean {
+        if ((!duplicated_visibility) && (value?.hasOwnProperty("visibility"))) {
+            return true
+        }
+        else if ((!duplicated_embedId) && (value?.hasOwnProperty("embedId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeEmbedVisibilityInfo")
+        }
+    }
+    static isNativeMediaPlayerConfig(value: Object | string | number | undefined | boolean, duplicated_enable: boolean, duplicated_shouldOverlay: boolean): boolean {
+        if ((!duplicated_enable) && (value?.hasOwnProperty("enable"))) {
+            return true
+        }
+        else if ((!duplicated_shouldOverlay) && (value?.hasOwnProperty("shouldOverlay"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeMediaPlayerConfig")
+        }
+    }
+    static isNativeXComponentParameters(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_imageAIOptions: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_imageAIOptions) && (value?.hasOwnProperty("imageAIOptions"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NativeXComponentParameters")
+        }
+    }
+    static isNavBarPosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavBarPosition.Start)) {
+            return true
+        }
+        else if ((value) === (NavBarPosition.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavBarPosition")
+        }
+    }
+    static isNavContentInfo(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_index: boolean, duplicated_mode: boolean, duplicated_param: boolean, duplicated_navDestinationId: boolean): boolean {
+        if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_mode) && (value?.hasOwnProperty("mode"))) {
+            return true
+        }
+        else if ((!duplicated_param) && (value?.hasOwnProperty("param"))) {
+            return true
+        }
+        else if ((!duplicated_navDestinationId) && (value?.hasOwnProperty("navDestinationId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavContentInfo")
+        }
+    }
+    static isNavDestinationActiveReason(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavDestinationActiveReason.TRANSITION)) {
+            return true
+        }
+        else if ((value) === (NavDestinationActiveReason.CONTENT_COVER)) {
+            return true
+        }
+        else if ((value) === (NavDestinationActiveReason.SHEET)) {
+            return true
+        }
+        else if ((value) === (NavDestinationActiveReason.DIALOG)) {
+            return true
+        }
+        else if ((value) === (NavDestinationActiveReason.OVERLAY)) {
+            return true
+        }
+        else if ((value) === (NavDestinationActiveReason.APP_STATE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationActiveReason")
+        }
+    }
+    static isNavDestinationCommonTitle(value: Object | string | number | undefined | boolean, duplicated_main: boolean, duplicated_sub: boolean): boolean {
+        if ((!duplicated_main) && (value?.hasOwnProperty("main"))) {
+            return true
+        }
+        else if ((!duplicated_sub) && (value?.hasOwnProperty("sub"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationCommonTitle")
+        }
+    }
+    static isNavDestinationContext(value: Object | string | number | undefined | boolean, duplicated_pathInfo: boolean, duplicated_pathStack: boolean, duplicated_navDestinationId: boolean): boolean {
+        if ((!duplicated_pathInfo) && (value?.hasOwnProperty("pathInfo"))) {
+            return true
+        }
+        else if ((!duplicated_pathStack) && (value?.hasOwnProperty("pathStack"))) {
+            return true
+        }
+        else if ((!duplicated_navDestinationId) && (value?.hasOwnProperty("navDestinationId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationContext")
+        }
+    }
+    static isNavDestinationCustomTitle(value: Object | string | number | undefined | boolean, duplicated_builder: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationCustomTitle")
+        }
+    }
+    static isNavDestinationMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavDestinationMode.STANDARD)) {
+            return true
+        }
+        else if ((value) === (NavDestinationMode.DIALOG)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationMode")
+        }
+    }
+    static isNavDestinationTransition(value: Object | string | number | undefined | boolean, duplicated_onTransitionEnd: boolean, duplicated_duration: boolean, duplicated_curve: boolean, duplicated_delay: boolean, duplicated_event: boolean): boolean {
+        if ((!duplicated_event) && (value?.hasOwnProperty("event"))) {
+            return true
+        }
+        else if ((!duplicated_onTransitionEnd) && (value?.hasOwnProperty("onTransitionEnd"))) {
+            return true
+        }
+        else if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else if ((!duplicated_curve) && (value?.hasOwnProperty("curve"))) {
+            return true
+        }
+        else if ((!duplicated_delay) && (value?.hasOwnProperty("delay"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavDestinationTransition")
+        }
+    }
+    static isNavigationAnimatedTransition(value: Object | string | number | undefined | boolean, duplicated_onTransitionEnd: boolean, duplicated_timeout: boolean, duplicated_isInteractive: boolean, duplicated_transition: boolean): boolean {
+        if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_onTransitionEnd) && (value?.hasOwnProperty("onTransitionEnd"))) {
+            return true
+        }
+        else if ((!duplicated_timeout) && (value?.hasOwnProperty("timeout"))) {
+            return true
+        }
+        else if ((!duplicated_isInteractive) && (value?.hasOwnProperty("isInteractive"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationAnimatedTransition")
+        }
+    }
+    static isNavigationCommonTitle(value: Object | string | number | undefined | boolean, duplicated_main: boolean, duplicated_sub: boolean): boolean {
+        if ((!duplicated_main) && (value?.hasOwnProperty("main"))) {
+            return true
+        }
+        else if ((!duplicated_sub) && (value?.hasOwnProperty("sub"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationCommonTitle")
+        }
+    }
+    static isNavigationCustomTitle(value: Object | string | number | undefined | boolean, duplicated_builder: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationCustomTitle")
+        }
+    }
+    static isNavigationInterception(value: Object | string | number | undefined | boolean, duplicated_willShow: boolean, duplicated_didShow: boolean, duplicated_modeChange: boolean): boolean {
+        if ((!duplicated_willShow) && (value?.hasOwnProperty("willShow"))) {
+            return true
+        }
+        else if ((!duplicated_didShow) && (value?.hasOwnProperty("didShow"))) {
+            return true
+        }
+        else if ((!duplicated_modeChange) && (value?.hasOwnProperty("modeChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationInterception")
+        }
+    }
+    static isNavigationMenuItem(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_icon: boolean, duplicated_symbolIcon: boolean, duplicated_isEnabled: boolean, duplicated_action: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolIcon) && (value?.hasOwnProperty("symbolIcon"))) {
+            return true
+        }
+        else if ((!duplicated_isEnabled) && (value?.hasOwnProperty("isEnabled"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationMenuItem")
+        }
+    }
+    static isNavigationMenuOptions(value: Object | string | number | undefined | boolean, duplicated_moreButtonOptions: boolean): boolean {
+        if ((!duplicated_moreButtonOptions) && (value?.hasOwnProperty("moreButtonOptions"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationMenuOptions")
+        }
+    }
+    static isNavigationMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavigationMode.Stack)) {
+            return true
+        }
+        else if ((value) === (NavigationMode.Split)) {
+            return true
+        }
+        else if ((value) === (NavigationMode.Auto)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationMode")
+        }
+    }
+    static isNavigationOperation(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavigationOperation.PUSH)) {
+            return true
+        }
+        else if ((value) === (NavigationOperation.POP)) {
+            return true
+        }
+        else if ((value) === (NavigationOperation.REPLACE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationOperation")
+        }
+    }
+    static isNavigationOptions(value: Object | string | number | undefined | boolean, duplicated_launchMode: boolean, duplicated_animated: boolean): boolean {
+        if ((!duplicated_launchMode) && (value?.hasOwnProperty("launchMode"))) {
+            return true
+        }
+        else if ((!duplicated_animated) && (value?.hasOwnProperty("animated"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationOptions")
+        }
+    }
+    static isNavigationSystemTransitionType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavigationSystemTransitionType.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.NONE)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.TITLE)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.CONTENT)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.FADE)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.EXPLODE)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.SLIDE_RIGHT)) {
+            return true
+        }
+        else if ((value) === (NavigationSystemTransitionType.SLIDE_BOTTOM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationSystemTransitionType")
+        }
+    }
+    static isNavigationTitleMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavigationTitleMode.Free)) {
+            return true
+        }
+        else if ((value) === (NavigationTitleMode.Full)) {
+            return true
+        }
+        else if ((value) === (NavigationTitleMode.Mini)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationTitleMode")
+        }
+    }
+    static isNavigationTitleOptions(value: Object | string | number | undefined | boolean, duplicated_backgroundColor: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_barStyle: boolean, duplicated_paddingStart: boolean, duplicated_paddingEnd: boolean, duplicated_mainTitleModifier: boolean, duplicated_subTitleModifier: boolean, duplicated_enableHoverMode: boolean): boolean {
+        if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_barStyle) && (value?.hasOwnProperty("barStyle"))) {
+            return true
+        }
+        else if ((!duplicated_paddingStart) && (value?.hasOwnProperty("paddingStart"))) {
+            return true
+        }
+        else if ((!duplicated_paddingEnd) && (value?.hasOwnProperty("paddingEnd"))) {
+            return true
+        }
+        else if ((!duplicated_mainTitleModifier) && (value?.hasOwnProperty("mainTitleModifier"))) {
+            return true
+        }
+        else if ((!duplicated_subTitleModifier) && (value?.hasOwnProperty("subTitleModifier"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationTitleOptions")
+        }
+    }
+    static isNavigationToolbarOptions(value: Object | string | number | undefined | boolean, duplicated_backgroundColor: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_moreButtonOptions: boolean, duplicated_barStyle: boolean, duplicated_hideItemValue: boolean): boolean {
+        if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_moreButtonOptions) && (value?.hasOwnProperty("moreButtonOptions"))) {
+            return true
+        }
+        else if ((!duplicated_barStyle) && (value?.hasOwnProperty("barStyle"))) {
+            return true
+        }
+        else if ((!duplicated_hideItemValue) && (value?.hasOwnProperty("hideItemValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationToolbarOptions")
+        }
+    }
+    static isNavigationTransitionProxy(value: Object | string | number | undefined | boolean, duplicated_from: boolean, duplicated_to: boolean, duplicated_isInteractive: boolean, duplicated_cancelTransition: boolean, duplicated_updateTransition: boolean): boolean {
+        if ((!duplicated_from) && (value?.hasOwnProperty("from"))) {
+            return true
+        }
+        else if ((!duplicated_to) && (value?.hasOwnProperty("to"))) {
+            return true
+        }
+        else if ((!duplicated_isInteractive) && (value?.hasOwnProperty("isInteractive"))) {
+            return true
+        }
+        else if ((!duplicated_cancelTransition) && (value?.hasOwnProperty("cancelTransition"))) {
+            return true
+        }
+        else if ((!duplicated_updateTransition) && (value?.hasOwnProperty("updateTransition"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationTransitionProxy")
+        }
+    }
+    static isNavigationType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NavigationType.PUSH)) {
+            return true
+        }
+        else if ((value) === (NavigationType.BACK)) {
+            return true
+        }
+        else if ((value) === (NavigationType.REPLACE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavigationType")
+        }
+    }
+    static isNavPathInfo(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_param: boolean, duplicated_onPop: boolean, duplicated_isEntry: boolean, duplicated_navDestinationId: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_param) && (value?.hasOwnProperty("param"))) {
+            return true
+        }
+        else if ((!duplicated_onPop) && (value?.hasOwnProperty("onPop"))) {
+            return true
+        }
+        else if ((!duplicated_isEntry) && (value?.hasOwnProperty("isEntry"))) {
+            return true
+        }
+        else if ((!duplicated_navDestinationId) && (value?.hasOwnProperty("navDestinationId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NavPathInfo")
+        }
+    }
+    static isNavPathStack(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof NavPathStack")
+    }
+    static isNestedScrollInfo(value: Object | string | number | undefined | boolean, duplicated_parent: boolean, duplicated_child: boolean): boolean {
+        if ((!duplicated_parent) && (value?.hasOwnProperty("parent"))) {
+            return true
+        }
+        else if ((!duplicated_child) && (value?.hasOwnProperty("child"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NestedScrollInfo")
+        }
+    }
+    static isNestedScrollMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (NestedScrollMode.SELF_ONLY)) {
+            return true
+        }
+        else if ((value) === (NestedScrollMode.SELF_FIRST)) {
+            return true
+        }
+        else if ((value) === (NestedScrollMode.PARENT_FIRST)) {
+            return true
+        }
+        else if ((value) === (NestedScrollMode.PARALLEL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NestedScrollMode")
+        }
+    }
+    static isNestedScrollOptions(value: Object | string | number | undefined | boolean, duplicated_scrollForward: boolean, duplicated_scrollBackward: boolean): boolean {
+        if ((!duplicated_scrollForward) && (value?.hasOwnProperty("scrollForward"))) {
+            return true
+        }
+        else if ((!duplicated_scrollBackward) && (value?.hasOwnProperty("scrollBackward"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NestedScrollOptions")
+        }
+    }
+    static isNestedScrollOptionsExt(value: Object | string | number | undefined | boolean, duplicated_scrollUp: boolean, duplicated_scrollDown: boolean, duplicated_scrollRight: boolean, duplicated_scrollLeft: boolean): boolean {
+        if ((!duplicated_scrollUp) && (value?.hasOwnProperty("scrollUp"))) {
+            return true
+        }
+        else if ((!duplicated_scrollDown) && (value?.hasOwnProperty("scrollDown"))) {
+            return true
+        }
+        else if ((!duplicated_scrollRight) && (value?.hasOwnProperty("scrollRight"))) {
+            return true
+        }
+        else if ((!duplicated_scrollLeft) && (value?.hasOwnProperty("scrollLeft"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NestedScrollOptionsExt")
+        }
+    }
+    static isNodeContent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof NodeContent")
+    }
+    static isNodeController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof NodeController")
+    }
+    static isNonCurrentDayStyle(value: Object | string | number | undefined | boolean, duplicated_nonCurrentMonthDayColor: boolean, duplicated_nonCurrentMonthLunarColor: boolean, duplicated_nonCurrentMonthWorkDayMarkColor: boolean, duplicated_nonCurrentMonthOffDayMarkColor: boolean): boolean {
+        if ((!duplicated_nonCurrentMonthDayColor) && (value?.hasOwnProperty("nonCurrentMonthDayColor"))) {
+            return true
+        }
+        else if ((!duplicated_nonCurrentMonthLunarColor) && (value?.hasOwnProperty("nonCurrentMonthLunarColor"))) {
+            return true
+        }
+        else if ((!duplicated_nonCurrentMonthWorkDayMarkColor) && (value?.hasOwnProperty("nonCurrentMonthWorkDayMarkColor"))) {
+            return true
+        }
+        else if ((!duplicated_nonCurrentMonthOffDayMarkColor) && (value?.hasOwnProperty("nonCurrentMonthOffDayMarkColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof NonCurrentDayStyle")
+        }
+    }
+    static isObscuredReasons(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ObscuredReasons.PLACEHOLDER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ObscuredReasons")
+        }
+    }
+    static isOffscreenCanvas(value: Object | string | number | undefined | boolean, duplicated_height: boolean, duplicated_width: boolean): boolean {
+        if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OffscreenCanvas")
+        }
+    }
+    static isOffscreenCanvasRenderingContext2D(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof OffscreenCanvasRenderingContext2D")
+    }
+    static isOffset(value: Object | string | number | undefined | boolean, duplicated_dx: boolean, duplicated_dy: boolean): boolean {
+        if ((!duplicated_dx) && (value?.hasOwnProperty("dx"))) {
+            return true
+        }
+        else if ((!duplicated_dy) && (value?.hasOwnProperty("dy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Offset")
+        }
+    }
+    static isOffset_componentutils(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Offset_componentutils")
+        }
+    }
+    static isOffsetOptions(value: Object | string | number | undefined | boolean, duplicated_xOffset: boolean, duplicated_yOffset: boolean): boolean {
+        if ((!duplicated_xOffset) && (value?.hasOwnProperty("xOffset"))) {
+            return true
+        }
+        else if ((!duplicated_yOffset) && (value?.hasOwnProperty("yOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OffsetOptions")
+        }
+    }
+    static isOffsetResult(value: Object | string | number | undefined | boolean, duplicated_xOffset: boolean, duplicated_yOffset: boolean): boolean {
+        if ((!duplicated_xOffset) && (value?.hasOwnProperty("xOffset"))) {
+            return true
+        }
+        else if ((!duplicated_yOffset) && (value?.hasOwnProperty("yOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OffsetResult")
+        }
+    }
+    static isOnAlertEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_message: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnAlertEvent")
+        }
+    }
+    static isOnAudioStateChangedEvent(value: Object | string | number | undefined | boolean, duplicated_playing: boolean): boolean {
+        if ((!duplicated_playing) && (value?.hasOwnProperty("playing"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnAudioStateChangedEvent")
+        }
+    }
+    static isOnBeforeUnloadEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_message: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnBeforeUnloadEvent")
+        }
+    }
+    static isOnClientAuthenticationEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean, duplicated_host: boolean, duplicated_port: boolean, duplicated_keyTypes: boolean, duplicated_issuers: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else if ((!duplicated_host) && (value?.hasOwnProperty("host"))) {
+            return true
+        }
+        else if ((!duplicated_port) && (value?.hasOwnProperty("port"))) {
+            return true
+        }
+        else if ((!duplicated_keyTypes) && (value?.hasOwnProperty("keyTypes"))) {
+            return true
+        }
+        else if ((!duplicated_issuers) && (value?.hasOwnProperty("issuers"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnClientAuthenticationEvent")
+        }
+    }
+    static isOnConfirmEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_message: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnConfirmEvent")
+        }
+    }
+    static isOnConsoleEvent(value: Object | string | number | undefined | boolean, duplicated_message: boolean): boolean {
+        if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnConsoleEvent")
+        }
+    }
+    static isOnContextMenuShowEvent(value: Object | string | number | undefined | boolean, duplicated_param: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_param) && (value?.hasOwnProperty("param"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnContextMenuShowEvent")
+        }
+    }
+    static isOnDataResubmittedEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnDataResubmittedEvent")
+        }
+    }
+    static isOnDownloadStartEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_userAgent: boolean, duplicated_contentDisposition: boolean, duplicated_mimetype: boolean, duplicated_contentLength: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_userAgent) && (value?.hasOwnProperty("userAgent"))) {
+            return true
+        }
+        else if ((!duplicated_contentDisposition) && (value?.hasOwnProperty("contentDisposition"))) {
+            return true
+        }
+        else if ((!duplicated_mimetype) && (value?.hasOwnProperty("mimetype"))) {
+            return true
+        }
+        else if ((!duplicated_contentLength) && (value?.hasOwnProperty("contentLength"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnDownloadStartEvent")
+        }
+    }
+    static isOnErrorReceiveEvent(value: Object | string | number | undefined | boolean, duplicated_request: boolean, duplicated_error: boolean): boolean {
+        if ((!duplicated_request) && (value?.hasOwnProperty("request"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnErrorReceiveEvent")
+        }
+    }
+    static isOnFaviconReceivedEvent(value: Object | string | number | undefined | boolean, duplicated_favicon: boolean): boolean {
+        if ((!duplicated_favicon) && (value?.hasOwnProperty("favicon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnFaviconReceivedEvent")
+        }
+    }
+    static isOnFirstContentfulPaintEvent(value: Object | string | number | undefined | boolean, duplicated_navigationStartTick: boolean, duplicated_firstContentfulPaintMs: boolean): boolean {
+        if ((!duplicated_navigationStartTick) && (value?.hasOwnProperty("navigationStartTick"))) {
+            return true
+        }
+        else if ((!duplicated_firstContentfulPaintMs) && (value?.hasOwnProperty("firstContentfulPaintMs"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnFirstContentfulPaintEvent")
+        }
+    }
+    static isOnFoldStatusChangeInfo(value: Object | string | number | undefined | boolean, duplicated_foldStatus: boolean): boolean {
+        if ((!duplicated_foldStatus) && (value?.hasOwnProperty("foldStatus"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnFoldStatusChangeInfo")
+        }
+    }
+    static isOnGeolocationShowEvent(value: Object | string | number | undefined | boolean, duplicated_origin: boolean, duplicated_geolocation: boolean): boolean {
+        if ((!duplicated_origin) && (value?.hasOwnProperty("origin"))) {
+            return true
+        }
+        else if ((!duplicated_geolocation) && (value?.hasOwnProperty("geolocation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnGeolocationShowEvent")
+        }
+    }
+    static isOnHttpAuthRequestEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean, duplicated_host: boolean, duplicated_realm: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else if ((!duplicated_host) && (value?.hasOwnProperty("host"))) {
+            return true
+        }
+        else if ((!duplicated_realm) && (value?.hasOwnProperty("realm"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnHttpAuthRequestEvent")
+        }
+    }
+    static isOnHttpErrorReceiveEvent(value: Object | string | number | undefined | boolean, duplicated_request: boolean, duplicated_response: boolean): boolean {
+        if ((!duplicated_request) && (value?.hasOwnProperty("request"))) {
+            return true
+        }
+        else if ((!duplicated_response) && (value?.hasOwnProperty("response"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnHttpErrorReceiveEvent")
+        }
+    }
+    static isOnInterceptRequestEvent(value: Object | string | number | undefined | boolean, duplicated_request: boolean): boolean {
+        if ((!duplicated_request) && (value?.hasOwnProperty("request"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnInterceptRequestEvent")
+        }
+    }
+    static isOnLoadInterceptEvent(value: Object | string | number | undefined | boolean, duplicated_data: boolean): boolean {
+        if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnLoadInterceptEvent")
+        }
+    }
+    static isOnOverScrollEvent(value: Object | string | number | undefined | boolean, duplicated_xOffset: boolean, duplicated_yOffset: boolean): boolean {
+        if ((!duplicated_xOffset) && (value?.hasOwnProperty("xOffset"))) {
+            return true
+        }
+        else if ((!duplicated_yOffset) && (value?.hasOwnProperty("yOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnOverScrollEvent")
+        }
+    }
+    static isOnPageBeginEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnPageBeginEvent")
+        }
+    }
+    static isOnPageEndEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnPageEndEvent")
+        }
+    }
+    static isOnPageVisibleEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnPageVisibleEvent")
+        }
+    }
+    static isOnPermissionRequestEvent(value: Object | string | number | undefined | boolean, duplicated_request: boolean): boolean {
+        if ((!duplicated_request) && (value?.hasOwnProperty("request"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnPermissionRequestEvent")
+        }
+    }
+    static isOnProgressChangeEvent(value: Object | string | number | undefined | boolean, duplicated_newProgress: boolean): boolean {
+        if ((!duplicated_newProgress) && (value?.hasOwnProperty("newProgress"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnProgressChangeEvent")
+        }
+    }
+    static isOnPromptEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_message: boolean, duplicated_value: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnPromptEvent")
+        }
+    }
+    static isOnRefreshAccessedHistoryEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_isRefreshed: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_isRefreshed) && (value?.hasOwnProperty("isRefreshed"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnRefreshAccessedHistoryEvent")
+        }
+    }
+    static isOnRenderExitedEvent(value: Object | string | number | undefined | boolean, duplicated_renderExitReason: boolean): boolean {
+        if ((!duplicated_renderExitReason) && (value?.hasOwnProperty("renderExitReason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnRenderExitedEvent")
+        }
+    }
+    static isOnResourceLoadEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnResourceLoadEvent")
+        }
+    }
+    static isOnScaleChangeEvent(value: Object | string | number | undefined | boolean, duplicated_oldScale: boolean, duplicated_newScale: boolean): boolean {
+        if ((!duplicated_oldScale) && (value?.hasOwnProperty("oldScale"))) {
+            return true
+        }
+        else if ((!duplicated_newScale) && (value?.hasOwnProperty("newScale"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnScaleChangeEvent")
+        }
+    }
+    static isOnScreenCaptureRequestEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnScreenCaptureRequestEvent")
+        }
+    }
+    static isOnScrollEvent(value: Object | string | number | undefined | boolean, duplicated_xOffset: boolean, duplicated_yOffset: boolean): boolean {
+        if ((!duplicated_xOffset) && (value?.hasOwnProperty("xOffset"))) {
+            return true
+        }
+        else if ((!duplicated_yOffset) && (value?.hasOwnProperty("yOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnScrollEvent")
+        }
+    }
+    static isOnScrollFrameBeginHandlerResult(value: Object | string | number | undefined | boolean, duplicated_offsetRemain: boolean): boolean {
+        if ((!duplicated_offsetRemain) && (value?.hasOwnProperty("offsetRemain"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnScrollFrameBeginHandlerResult")
+        }
+    }
+    static isOnSearchResultReceiveEvent(value: Object | string | number | undefined | boolean, duplicated_activeMatchOrdinal: boolean, duplicated_numberOfMatches: boolean, duplicated_isDoneCounting: boolean): boolean {
+        if ((!duplicated_activeMatchOrdinal) && (value?.hasOwnProperty("activeMatchOrdinal"))) {
+            return true
+        }
+        else if ((!duplicated_numberOfMatches) && (value?.hasOwnProperty("numberOfMatches"))) {
+            return true
+        }
+        else if ((!duplicated_isDoneCounting) && (value?.hasOwnProperty("isDoneCounting"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnSearchResultReceiveEvent")
+        }
+    }
+    static isOnShowFileSelectorEvent(value: Object | string | number | undefined | boolean, duplicated_result: boolean, duplicated_fileSelector: boolean): boolean {
+        if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else if ((!duplicated_fileSelector) && (value?.hasOwnProperty("fileSelector"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnShowFileSelectorEvent")
+        }
+    }
+    static isOnSslErrorEventReceiveEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean, duplicated_error: boolean, duplicated_certChainData: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else if ((!duplicated_certChainData) && (value?.hasOwnProperty("certChainData"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnSslErrorEventReceiveEvent")
+        }
+    }
+    static isOnTitleReceiveEvent(value: Object | string | number | undefined | boolean, duplicated_title: boolean): boolean {
+        if ((!duplicated_title) && (value?.hasOwnProperty("title"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnTitleReceiveEvent")
+        }
+    }
+    static isOnTouchIconUrlReceivedEvent(value: Object | string | number | undefined | boolean, duplicated_url: boolean, duplicated_precomposed: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_precomposed) && (value?.hasOwnProperty("precomposed"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnTouchIconUrlReceivedEvent")
+        }
+    }
+    static isOnWindowNewEvent(value: Object | string | number | undefined | boolean, duplicated_isAlert: boolean, duplicated_isUserTrigger: boolean, duplicated_targetUrl: boolean, duplicated_handler: boolean): boolean {
+        if ((!duplicated_isAlert) && (value?.hasOwnProperty("isAlert"))) {
+            return true
+        }
+        else if ((!duplicated_isUserTrigger) && (value?.hasOwnProperty("isUserTrigger"))) {
+            return true
+        }
+        else if ((!duplicated_targetUrl) && (value?.hasOwnProperty("targetUrl"))) {
+            return true
+        }
+        else if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OnWindowNewEvent")
+        }
+    }
+    static isOptionWidthMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (OptionWidthMode.FIT_CONTENT)) {
+            return true
+        }
+        else if ((value) === (OptionWidthMode.FIT_TRIGGER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OptionWidthMode")
+        }
+    }
+    static isOutlineOptions(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_color: boolean, duplicated_radius: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OutlineOptions")
+        }
+    }
+    static isOutlineRadiuses(value: Object | string | number | undefined | boolean, duplicated_topLeft: boolean, duplicated_topRight: boolean, duplicated_bottomLeft: boolean, duplicated_bottomRight: boolean): boolean {
+        if ((!duplicated_topLeft) && (value?.hasOwnProperty("topLeft"))) {
+            return true
+        }
+        else if ((!duplicated_topRight) && (value?.hasOwnProperty("topRight"))) {
+            return true
+        }
+        else if ((!duplicated_bottomLeft) && (value?.hasOwnProperty("bottomLeft"))) {
+            return true
+        }
+        else if ((!duplicated_bottomRight) && (value?.hasOwnProperty("bottomRight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OutlineRadiuses")
+        }
+    }
+    static isOutlineStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (OutlineStyle.SOLID)) {
+            return true
+        }
+        else if ((value) === (OutlineStyle.DASHED)) {
+            return true
+        }
+        else if ((value) === (OutlineStyle.DOTTED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OutlineStyle")
+        }
+    }
+    static isOverlayOffset(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OverlayOffset")
+        }
+    }
+    static isOverlayOptions(value: Object | string | number | undefined | boolean, duplicated_align: boolean, duplicated_offset: boolean): boolean {
+        if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OverlayOptions")
+        }
+    }
+    static isOverScrollMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (OverScrollMode.NEVER)) {
+            return true
+        }
+        else if ((value) === (OverScrollMode.ALWAYS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof OverScrollMode")
+        }
+    }
+    static isPadding(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_right: boolean, duplicated_bottom: boolean, duplicated_left: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Padding")
+        }
+    }
+    static isPageFlipMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PageFlipMode.CONTINUOUS)) {
+            return true
+        }
+        else if ((value) === (PageFlipMode.SINGLE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PageFlipMode")
+        }
+    }
+    static isPageLifeCycle(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PageLifeCycle")
+    }
+    static isPanDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PanDirection.None)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Horizontal)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Left)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Right)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Vertical)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Up)) {
+            return true
+        }
+        else if ((value) === (PanDirection.Down)) {
+            return true
+        }
+        else if ((value) === (PanDirection.All)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PanDirection")
+        }
+    }
+    static isPanGestureEvent(value: Object | string | number | undefined | boolean, duplicated_offsetX: boolean, duplicated_offsetY: boolean, duplicated_velocityX: boolean, duplicated_velocityY: boolean, duplicated_velocity: boolean): boolean {
+        if ((!duplicated_offsetX) && (value?.hasOwnProperty("offsetX"))) {
+            return true
+        }
+        else if ((!duplicated_offsetY) && (value?.hasOwnProperty("offsetY"))) {
+            return true
+        }
+        else if ((!duplicated_velocityX) && (value?.hasOwnProperty("velocityX"))) {
+            return true
+        }
+        else if ((!duplicated_velocityY) && (value?.hasOwnProperty("velocityY"))) {
+            return true
+        }
+        else if ((!duplicated_velocity) && (value?.hasOwnProperty("velocity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PanGestureEvent")
+        }
+    }
+    static isPanGestureHandlerOptions(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_direction: boolean, duplicated_distance: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_distance) && (value?.hasOwnProperty("distance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PanGestureHandlerOptions")
+        }
+    }
+    static isPanGestureInterface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PanGestureInterface")
+    }
+    static isPanGestureInterface_Invoke_Literal(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_direction: boolean, duplicated_distance: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_distance) && (value?.hasOwnProperty("distance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PanGestureInterface_Invoke_Literal")
+        }
+    }
+    static isPanGestureOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PanGestureOptions")
+    }
+    static isPanRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PanRecognizer")
+    }
+    static isParagraphStyle(value: Object | string | number | undefined | boolean, duplicated_textAlign: boolean, duplicated_textIndent: boolean, duplicated_maxLines: boolean, duplicated_overflow: boolean, duplicated_wordBreak: boolean, duplicated_leadingMargin: boolean, duplicated_paragraphSpacing: boolean): boolean {
+        if ((!duplicated_textAlign) && (value?.hasOwnProperty("textAlign"))) {
+            return true
+        }
+        else if ((!duplicated_textIndent) && (value?.hasOwnProperty("textIndent"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else if ((!duplicated_wordBreak) && (value?.hasOwnProperty("wordBreak"))) {
+            return true
+        }
+        else if ((!duplicated_leadingMargin) && (value?.hasOwnProperty("leadingMargin"))) {
+            return true
+        }
+        else if ((!duplicated_paragraphSpacing) && (value?.hasOwnProperty("paragraphSpacing"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ParagraphStyle")
+        }
+    }
+    static isParagraphStyleInterface(value: Object | string | number | undefined | boolean, duplicated_textAlign: boolean, duplicated_textIndent: boolean, duplicated_maxLines: boolean, duplicated_overflow: boolean, duplicated_wordBreak: boolean, duplicated_leadingMargin: boolean, duplicated_paragraphSpacing: boolean): boolean {
+        if ((!duplicated_textAlign) && (value?.hasOwnProperty("textAlign"))) {
+            return true
+        }
+        else if ((!duplicated_textIndent) && (value?.hasOwnProperty("textIndent"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else if ((!duplicated_wordBreak) && (value?.hasOwnProperty("wordBreak"))) {
+            return true
+        }
+        else if ((!duplicated_leadingMargin) && (value?.hasOwnProperty("leadingMargin"))) {
+            return true
+        }
+        else if ((!duplicated_paragraphSpacing) && (value?.hasOwnProperty("paragraphSpacing"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ParagraphStyleInterface")
+        }
+    }
+    static isParticleEmitterShape(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ParticleEmitterShape.RECTANGLE)) {
+            return true
+        }
+        else if ((value) === (ParticleEmitterShape.CIRCLE)) {
+            return true
+        }
+        else if ((value) === (ParticleEmitterShape.ELLIPSE)) {
+            return true
+        }
+        else if ((value) === (ParticleEmitterShape.ANNULUS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ParticleEmitterShape")
+        }
+    }
+    static isParticleType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ParticleType.POINT)) {
+            return true
+        }
+        else if ((value) === (ParticleType.IMAGE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ParticleType")
+        }
+    }
+    static isParticleUpdater(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ParticleUpdater.NONE)) {
+            return true
+        }
+        else if ((value) === (ParticleUpdater.RANDOM)) {
+            return true
+        }
+        else if ((value) === (ParticleUpdater.CURVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ParticleUpdater")
+        }
+    }
+    static isPasswordIcon(value: Object | string | number | undefined | boolean, duplicated_onIconSrc: boolean, duplicated_offIconSrc: boolean): boolean {
+        if ((!duplicated_onIconSrc) && (value?.hasOwnProperty("onIconSrc"))) {
+            return true
+        }
+        else if ((!duplicated_offIconSrc) && (value?.hasOwnProperty("offIconSrc"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PasswordIcon")
+        }
+    }
+    static isPasteButtonOnClickResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PasteButtonOnClickResult.SUCCESS)) {
+            return true
+        }
+        else if ((value) === (PasteButtonOnClickResult.TEMPORARY_AUTHORIZATION_FAILED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PasteButtonOnClickResult")
+        }
+    }
+    static isPasteDescription(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PasteDescription.PASTE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PasteDescription")
+        }
+    }
+    static isPasteEvent(value: Object | string | number | undefined | boolean, duplicated_preventDefault: boolean): boolean {
+        if ((!duplicated_preventDefault) && (value?.hasOwnProperty("preventDefault"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PasteEvent")
+        }
+    }
+    static isPasteIconStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PasteIconStyle.LINES)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PasteIconStyle")
+        }
+    }
+    static isPath2D(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof Path2D")
+    }
+    static isPathOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PathOptions")
+    }
+    static isPathShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PathShape")
+    }
+    static isPathShapeOptions(value: Object | string | number | undefined | boolean, duplicated_commands: boolean): boolean {
+        if ((!duplicated_commands) && (value?.hasOwnProperty("commands"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PathShapeOptions")
+        }
+    }
+    static isPatternLockChallengeResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PatternLockChallengeResult.CORRECT)) {
+            return true
+        }
+        else if ((value) === (PatternLockChallengeResult.WRONG)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PatternLockChallengeResult")
+        }
+    }
+    static isPatternLockController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PatternLockController")
+    }
+    static isPerfMonitorActionType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PerfMonitorActionType.LAST_DOWN)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorActionType.LAST_UP)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorActionType.FIRST_MOVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PerfMonitorActionType")
+        }
+    }
+    static isPerfMonitorSourceType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PerfMonitorSourceType.PERF_TOUCH_EVENT)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorSourceType.PERF_MOUSE_EVENT)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorSourceType.PERF_TOUCHPAD_EVENT)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorSourceType.PERF_JOYSTICK_EVENT)) {
+            return true
+        }
+        else if ((value) === (PerfMonitorSourceType.PERF_KEY_EVENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PerfMonitorSourceType")
+        }
+    }
+    static isPermissionRequest(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PermissionRequest")
+    }
+    static isPickerDialogButtonStyle(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_style: boolean, duplicated_role: boolean, duplicated_fontSize: boolean, duplicated_fontColor: boolean, duplicated_fontWeight: boolean, duplicated_fontStyle: boolean, duplicated_fontFamily: boolean, duplicated_backgroundColor: boolean, duplicated_borderRadius: boolean, duplicated_primary: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_role) && (value?.hasOwnProperty("role"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else if ((!duplicated_primary) && (value?.hasOwnProperty("primary"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PickerDialogButtonStyle")
+        }
+    }
+    static isPickerTextStyle(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_font: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PickerTextStyle")
+        }
+    }
+    static isPinchGestureEvent(value: Object | string | number | undefined | boolean, duplicated_scale: boolean, duplicated_pinchCenterX: boolean, duplicated_pinchCenterY: boolean): boolean {
+        if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_pinchCenterX) && (value?.hasOwnProperty("pinchCenterX"))) {
+            return true
+        }
+        else if ((!duplicated_pinchCenterY) && (value?.hasOwnProperty("pinchCenterY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PinchGestureEvent")
+        }
+    }
+    static isPinchGestureHandlerOptions(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_distance: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_distance) && (value?.hasOwnProperty("distance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PinchGestureHandlerOptions")
+        }
+    }
+    static isPinchGestureInterface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PinchGestureInterface")
+    }
+    static isPinchGestureInterface_Invoke_Literal(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_distance: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_distance) && (value?.hasOwnProperty("distance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PinchGestureInterface_Invoke_Literal")
+        }
+    }
+    static isPinchRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PinchRecognizer")
+    }
+    static isPixelMapMock(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PixelMapMock")
+    }
+    static isPixelRoundCalcPolicy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PixelRoundCalcPolicy.NO_FORCE_ROUND)) {
+            return true
+        }
+        else if ((value) === (PixelRoundCalcPolicy.FORCE_CEIL)) {
+            return true
+        }
+        else if ((value) === (PixelRoundCalcPolicy.FORCE_FLOOR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PixelRoundCalcPolicy")
+        }
+    }
+    static isPixelRoundMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PixelRoundMode.PIXEL_ROUND_ON_LAYOUT_FINISH)) {
+            return true
+        }
+        else if ((value) === (PixelRoundMode.PIXEL_ROUND_AFTER_MEASURE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PixelRoundMode")
+        }
+    }
+    static isPixelRoundPolicy(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_top: boolean, duplicated_end: boolean, duplicated_bottom: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PixelRoundPolicy")
+        }
+    }
+    static isPixelStretchEffectOptions(value: Object | string | number | undefined | boolean, duplicated_top: boolean, duplicated_bottom: boolean, duplicated_left: boolean, duplicated_right: boolean): boolean {
+        if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_bottom) && (value?.hasOwnProperty("bottom"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_right) && (value?.hasOwnProperty("right"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PixelStretchEffectOptions")
+        }
+    }
+    static isPlaceholderStyle(value: Object | string | number | undefined | boolean, duplicated_font: boolean, duplicated_fontColor: boolean): boolean {
+        if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PlaceholderStyle")
+        }
+    }
+    static isPlacement(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Placement.Left)) {
+            return true
+        }
+        else if ((value) === (Placement.Right)) {
+            return true
+        }
+        else if ((value) === (Placement.Top)) {
+            return true
+        }
+        else if ((value) === (Placement.Bottom)) {
+            return true
+        }
+        else if ((value) === (Placement.TopLeft)) {
+            return true
+        }
+        else if ((value) === (Placement.TopRight)) {
+            return true
+        }
+        else if ((value) === (Placement.BottomLeft)) {
+            return true
+        }
+        else if ((value) === (Placement.BottomRight)) {
+            return true
+        }
+        else if ((value) === (Placement.LeftTop)) {
+            return true
+        }
+        else if ((value) === (Placement.LeftBottom)) {
+            return true
+        }
+        else if ((value) === (Placement.RightTop)) {
+            return true
+        }
+        else if ((value) === (Placement.RightBottom)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Placement")
+        }
+    }
+    static isPlaybackInfo(value: Object | string | number | undefined | boolean, duplicated_time: boolean): boolean {
+        if ((!duplicated_time) && (value?.hasOwnProperty("time"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PlaybackInfo")
+        }
+    }
+    static isPlaybackSpeed(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PlaybackSpeed.Speed_Forward_0_75_X)) {
+            return true
+        }
+        else if ((value) === (PlaybackSpeed.Speed_Forward_1_00_X)) {
+            return true
+        }
+        else if ((value) === (PlaybackSpeed.Speed_Forward_1_25_X)) {
+            return true
+        }
+        else if ((value) === (PlaybackSpeed.Speed_Forward_1_75_X)) {
+            return true
+        }
+        else if ((value) === (PlaybackSpeed.Speed_Forward_2_00_X)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PlaybackSpeed")
+        }
+    }
+    static isPlayMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PlayMode.Normal)) {
+            return true
+        }
+        else if ((value) === (PlayMode.Reverse)) {
+            return true
+        }
+        else if ((value) === (PlayMode.Alternate)) {
+            return true
+        }
+        else if ((value) === (PlayMode.AlternateReverse)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PlayMode")
+        }
+    }
+    static isPluginComponentOptions(value: Object | string | number | undefined | boolean, duplicated_template: boolean, duplicated_data: boolean): boolean {
+        if ((!duplicated_template) && (value?.hasOwnProperty("template"))) {
+            return true
+        }
+        else if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PluginComponentOptions")
+        }
+    }
+    static isPluginComponentTemplate(value: Object | string | number | undefined | boolean, duplicated_source: boolean, duplicated_bundleName: boolean): boolean {
+        if ((!duplicated_source) && (value?.hasOwnProperty("source"))) {
+            return true
+        }
+        else if ((!duplicated_bundleName) && (value?.hasOwnProperty("bundleName"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PluginComponentTemplate")
+        }
+    }
+    static isPluginErrorData(value: Object | string | number | undefined | boolean, duplicated_errcode: boolean, duplicated_msg: boolean): boolean {
+        if ((!duplicated_errcode) && (value?.hasOwnProperty("errcode"))) {
+            return true
+        }
+        else if ((!duplicated_msg) && (value?.hasOwnProperty("msg"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PluginErrorData")
+        }
+    }
+    static ispointer_PointerStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (pointer.PointerStyle.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.SOUTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.WEST_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH_SOUTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.SOUTH_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.SOUTH_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH_EAST_SOUTH_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.NORTH_WEST_SOUTH_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.CROSS)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.CURSOR_COPY)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.CURSOR_FORBID)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.COLOR_SUCKER)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.HAND_GRABBING)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.HAND_OPEN)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.HAND_POINTING)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.HELP)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MOVE)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.RESIZE_LEFT_RIGHT)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.RESIZE_UP_DOWN)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.SCREENSHOT_CHOOSE)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.SCREENSHOT_CURSOR)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.TEXT_CURSOR)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.ZOOM_IN)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.ZOOM_OUT)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_SOUTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_NORTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_NORTH_SOUTH)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_NORTH_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_NORTH_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_SOUTH_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_SOUTH_WEST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.MIDDLE_BTN_NORTH_SOUTH_WEST_EAST)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.HORIZONTAL_TEXT_CURSOR)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.CURSOR_CROSS)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.CURSOR_CIRCLE)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.LOADING)) {
+            return true
+        }
+        else if ((value) === (pointer.PointerStyle.RUNNING)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof pointer.PointerStyle")
+        }
+    }
+    static isPointLightStyle(value: Object | string | number | undefined | boolean, duplicated_lightSource: boolean, duplicated_illuminated: boolean, duplicated_bloom: boolean): boolean {
+        if ((!duplicated_lightSource) && (value?.hasOwnProperty("lightSource"))) {
+            return true
+        }
+        else if ((!duplicated_illuminated) && (value?.hasOwnProperty("illuminated"))) {
+            return true
+        }
+        else if ((!duplicated_bloom) && (value?.hasOwnProperty("bloom"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PointLightStyle")
+        }
+    }
+    static isPolygonOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PolygonOptions")
+    }
+    static isPolylineOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PolylineOptions")
+    }
+    static isPopInfo(value: Object | string | number | undefined | boolean, duplicated_info: boolean, duplicated_result: boolean): boolean {
+        if ((!duplicated_info) && (value?.hasOwnProperty("info"))) {
+            return true
+        }
+        else if ((!duplicated_result) && (value?.hasOwnProperty("result"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopInfo")
+        }
+    }
+    static isPopupButton(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_action: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupButton")
+        }
+    }
+    static isPopupCommonOptions(value: Object | string | number | undefined | boolean, duplicated_placement: boolean, duplicated_popupColor: boolean, duplicated_enableArrow: boolean, duplicated_autoCancel: boolean, duplicated_onStateChange: boolean, duplicated_arrowOffset: boolean, duplicated_showInSubWindow: boolean, duplicated_mask: boolean, duplicated_targetSpace: boolean, duplicated_offset: boolean, duplicated_width: boolean, duplicated_arrowPointPosition: boolean, duplicated_arrowWidth: boolean, duplicated_arrowHeight: boolean, duplicated_radius: boolean, duplicated_shadow: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_focusable: boolean, duplicated_transition: boolean, duplicated_onWillDismiss: boolean, duplicated_enableHoverMode: boolean, duplicated_followTransformOfTarget: boolean): boolean {
+        if ((!duplicated_placement) && (value?.hasOwnProperty("placement"))) {
+            return true
+        }
+        else if ((!duplicated_popupColor) && (value?.hasOwnProperty("popupColor"))) {
+            return true
+        }
+        else if ((!duplicated_enableArrow) && (value?.hasOwnProperty("enableArrow"))) {
+            return true
+        }
+        else if ((!duplicated_autoCancel) && (value?.hasOwnProperty("autoCancel"))) {
+            return true
+        }
+        else if ((!duplicated_onStateChange) && (value?.hasOwnProperty("onStateChange"))) {
+            return true
+        }
+        else if ((!duplicated_arrowOffset) && (value?.hasOwnProperty("arrowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else if ((!duplicated_mask) && (value?.hasOwnProperty("mask"))) {
+            return true
+        }
+        else if ((!duplicated_targetSpace) && (value?.hasOwnProperty("targetSpace"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_arrowPointPosition) && (value?.hasOwnProperty("arrowPointPosition"))) {
+            return true
+        }
+        else if ((!duplicated_arrowWidth) && (value?.hasOwnProperty("arrowWidth"))) {
+            return true
+        }
+        else if ((!duplicated_arrowHeight) && (value?.hasOwnProperty("arrowHeight"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_focusable) && (value?.hasOwnProperty("focusable"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_followTransformOfTarget) && (value?.hasOwnProperty("followTransformOfTarget"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupCommonOptions")
+        }
+    }
+    static isPopupMaskType(value: Object | string | number | undefined | boolean, duplicated_color: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupMaskType")
+        }
+    }
+    static isPopupMessageOptions(value: Object | string | number | undefined | boolean, duplicated_textColor: boolean, duplicated_font: boolean): boolean {
+        if ((!duplicated_textColor) && (value?.hasOwnProperty("textColor"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupMessageOptions")
+        }
+    }
+    static isPopupOptions(value: Object | string | number | undefined | boolean, duplicated_message: boolean, duplicated_placement: boolean, duplicated_primaryButton: boolean, duplicated_secondaryButton: boolean, duplicated_onStateChange: boolean, duplicated_arrowOffset: boolean, duplicated_showInSubWindow: boolean, duplicated_mask: boolean, duplicated_messageOptions: boolean, duplicated_targetSpace: boolean, duplicated_enableArrow: boolean, duplicated_offset: boolean, duplicated_popupColor: boolean, duplicated_autoCancel: boolean, duplicated_width: boolean, duplicated_arrowPointPosition: boolean, duplicated_arrowWidth: boolean, duplicated_arrowHeight: boolean, duplicated_radius: boolean, duplicated_shadow: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_transition: boolean, duplicated_onWillDismiss: boolean, duplicated_enableHoverMode: boolean, duplicated_followTransformOfTarget: boolean, duplicated_keyboardAvoidMode: boolean): boolean {
+        if ((!duplicated_message) && (value?.hasOwnProperty("message"))) {
+            return true
+        }
+        else if ((!duplicated_placement) && (value?.hasOwnProperty("placement"))) {
+            return true
+        }
+        else if ((!duplicated_primaryButton) && (value?.hasOwnProperty("primaryButton"))) {
+            return true
+        }
+        else if ((!duplicated_secondaryButton) && (value?.hasOwnProperty("secondaryButton"))) {
+            return true
+        }
+        else if ((!duplicated_onStateChange) && (value?.hasOwnProperty("onStateChange"))) {
+            return true
+        }
+        else if ((!duplicated_arrowOffset) && (value?.hasOwnProperty("arrowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else if ((!duplicated_mask) && (value?.hasOwnProperty("mask"))) {
+            return true
+        }
+        else if ((!duplicated_messageOptions) && (value?.hasOwnProperty("messageOptions"))) {
+            return true
+        }
+        else if ((!duplicated_targetSpace) && (value?.hasOwnProperty("targetSpace"))) {
+            return true
+        }
+        else if ((!duplicated_enableArrow) && (value?.hasOwnProperty("enableArrow"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_popupColor) && (value?.hasOwnProperty("popupColor"))) {
+            return true
+        }
+        else if ((!duplicated_autoCancel) && (value?.hasOwnProperty("autoCancel"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_arrowPointPosition) && (value?.hasOwnProperty("arrowPointPosition"))) {
+            return true
+        }
+        else if ((!duplicated_arrowWidth) && (value?.hasOwnProperty("arrowWidth"))) {
+            return true
+        }
+        else if ((!duplicated_arrowHeight) && (value?.hasOwnProperty("arrowHeight"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_followTransformOfTarget) && (value?.hasOwnProperty("followTransformOfTarget"))) {
+            return true
+        }
+        else if ((!duplicated_keyboardAvoidMode) && (value?.hasOwnProperty("keyboardAvoidMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupOptions")
+        }
+    }
+    static isPopupStateChangeParam(value: Object | string | number | undefined | boolean, duplicated_isVisible: boolean): boolean {
+        if ((!duplicated_isVisible) && (value?.hasOwnProperty("isVisible"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PopupStateChangeParam")
+        }
+    }
+    static isPosition(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Position")
+        }
+    }
+    static isPositionWithAffinity(value: Object | string | number | undefined | boolean, duplicated_position: boolean): boolean {
+        if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PositionWithAffinity")
+        }
+    }
+    static isPosterOptions(value: Object | string | number | undefined | boolean, duplicated_showFirstFrame: boolean): boolean {
+        if ((!duplicated_showFirstFrame) && (value?.hasOwnProperty("showFirstFrame"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PosterOptions")
+        }
+    }
+    static isPostMessageOptions(value: Object | string | number | undefined | boolean, duplicated_transfer: boolean): boolean {
+        if ((!duplicated_transfer) && (value?.hasOwnProperty("transfer"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PostMessageOptions")
+        }
+    }
+    static isPreDragStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (PreDragStatus.ACTION_DETECTING_STATUS)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.READY_TO_TRIGGER_DRAG_ACTION)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.PREVIEW_LIFT_STARTED)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.PREVIEW_LIFT_FINISHED)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.PREVIEW_LANDING_STARTED)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.PREVIEW_LANDING_FINISHED)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.ACTION_CANCELED_BEFORE_DRAG)) {
+            return true
+        }
+        else if ((value) === (PreDragStatus.PREPARING_FOR_DRAG_DETECTION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PreDragStatus")
+        }
+    }
+    static isPreparedInfo(value: Object | string | number | undefined | boolean, duplicated_duration: boolean): boolean {
+        if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PreparedInfo")
+        }
+    }
+    static isPreviewConfiguration(value: Object | string | number | undefined | boolean, duplicated_onlyForLifting: boolean, duplicated_delayCreating: boolean): boolean {
+        if ((!duplicated_onlyForLifting) && (value?.hasOwnProperty("onlyForLifting"))) {
+            return true
+        }
+        else if ((!duplicated_delayCreating) && (value?.hasOwnProperty("delayCreating"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PreviewConfiguration")
+        }
+    }
+    static isPreviewMenuOptions(value: Object | string | number | undefined | boolean, duplicated_hapticFeedbackMode: boolean): boolean {
+        if ((!duplicated_hapticFeedbackMode) && (value?.hasOwnProperty("hapticFeedbackMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PreviewMenuOptions")
+        }
+    }
+    static isPreviewText(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_value: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof PreviewText")
+        }
+    }
+    static isProgressConfiguration(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_total: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_total) && (value?.hasOwnProperty("total"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressConfiguration")
+        }
+    }
+    static isProgressMask(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ProgressMask")
+    }
+    static isProgressOptions(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_total: boolean, duplicated_type: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_total) && (value?.hasOwnProperty("total"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressOptions")
+        }
+    }
+    static isProgressStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ProgressStatus.LOADING)) {
+            return true
+        }
+        else if ((value) === (ProgressStatus.PROGRESSING)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressStatus")
+        }
+    }
+    static isProgressStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ProgressStyle.Linear)) {
+            return true
+        }
+        else if ((value) === (ProgressStyle.Ring)) {
+            return true
+        }
+        else if ((value) === (ProgressStyle.Eclipse)) {
+            return true
+        }
+        else if ((value) === (ProgressStyle.ScaleRing)) {
+            return true
+        }
+        else if ((value) === (ProgressStyle.Capsule)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressStyle")
+        }
+    }
+    static isProgressStyleOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_scaleCount: boolean, duplicated_scaleWidth: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_scaleCount) && (value?.hasOwnProperty("scaleCount"))) {
+            return true
+        }
+        else if ((!duplicated_scaleWidth) && (value?.hasOwnProperty("scaleWidth"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressStyleOptions")
+        }
+    }
+    static isProgressType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ProgressType.Linear)) {
+            return true
+        }
+        else if ((value) === (ProgressType.Ring)) {
+            return true
+        }
+        else if ((value) === (ProgressType.Eclipse)) {
+            return true
+        }
+        else if ((value) === (ProgressType.ScaleRing)) {
+            return true
+        }
+        else if ((value) === (ProgressType.Capsule)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProgressType")
+        }
+    }
+    static isPromptAction(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof PromptAction")
+    }
+    static isProtectedResourceType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ProtectedResourceType.MidiSysex)) {
+            return true
+        }
+        else if ((value) === (ProtectedResourceType.VIDEO_CAPTURE)) {
+            return true
+        }
+        else if ((value) === (ProtectedResourceType.AUDIO_CAPTURE)) {
+            return true
+        }
+        else if ((value) === (ProtectedResourceType.SENSOR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ProtectedResourceType")
+        }
+    }
+    static isRadialGradientOptions(value: Object | string | number | undefined | boolean, duplicated_center: boolean, duplicated_radius: boolean, duplicated_colors: boolean, duplicated_repeating: boolean): boolean {
+        if ((!duplicated_center) && (value?.hasOwnProperty("center"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_colors) && (value?.hasOwnProperty("colors"))) {
+            return true
+        }
+        else if ((!duplicated_repeating) && (value?.hasOwnProperty("repeating"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RadialGradientOptions")
+        }
+    }
+    static isRadioConfiguration(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_checked: boolean, duplicated_triggerChange: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_checked) && (value?.hasOwnProperty("checked"))) {
+            return true
+        }
+        else if ((!duplicated_triggerChange) && (value?.hasOwnProperty("triggerChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RadioConfiguration")
+        }
+    }
+    static isRadioIndicatorType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RadioIndicatorType.TICK)) {
+            return true
+        }
+        else if ((value) === (RadioIndicatorType.DOT)) {
+            return true
+        }
+        else if ((value) === (RadioIndicatorType.CUSTOM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RadioIndicatorType")
+        }
+    }
+    static isRadioOptions(value: Object | string | number | undefined | boolean, duplicated_group: boolean, duplicated_value: boolean, duplicated_indicatorType: boolean, duplicated_indicatorBuilder: boolean): boolean {
+        if ((!duplicated_group) && (value?.hasOwnProperty("group"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_indicatorType) && (value?.hasOwnProperty("indicatorType"))) {
+            return true
+        }
+        else if ((!duplicated_indicatorBuilder) && (value?.hasOwnProperty("indicatorBuilder"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RadioOptions")
+        }
+    }
+    static isRadioStyle(value: Object | string | number | undefined | boolean, duplicated_checkedBackgroundColor: boolean, duplicated_uncheckedBorderColor: boolean, duplicated_indicatorColor: boolean): boolean {
+        if ((!duplicated_checkedBackgroundColor) && (value?.hasOwnProperty("checkedBackgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_uncheckedBorderColor) && (value?.hasOwnProperty("uncheckedBorderColor"))) {
+            return true
+        }
+        else if ((!duplicated_indicatorColor) && (value?.hasOwnProperty("indicatorColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RadioStyle")
+        }
+    }
+    static isRatingConfiguration(value: Object | string | number | undefined | boolean, duplicated_rating: boolean, duplicated_indicator: boolean, duplicated_stars: boolean, duplicated_stepSize: boolean, duplicated_triggerChange: boolean): boolean {
+        if ((!duplicated_rating) && (value?.hasOwnProperty("rating"))) {
+            return true
+        }
+        else if ((!duplicated_indicator) && (value?.hasOwnProperty("indicator"))) {
+            return true
+        }
+        else if ((!duplicated_stars) && (value?.hasOwnProperty("stars"))) {
+            return true
+        }
+        else if ((!duplicated_stepSize) && (value?.hasOwnProperty("stepSize"))) {
+            return true
+        }
+        else if ((!duplicated_triggerChange) && (value?.hasOwnProperty("triggerChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RatingConfiguration")
+        }
+    }
+    static isRatingOptions(value: Object | string | number | undefined | boolean, duplicated_rating: boolean, duplicated_indicator: boolean): boolean {
+        if ((!duplicated_rating) && (value?.hasOwnProperty("rating"))) {
+            return true
+        }
+        else if ((!duplicated_indicator) && (value?.hasOwnProperty("indicator"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RatingOptions")
+        }
+    }
+    static isRectangle(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Rectangle")
+        }
+    }
+    static isRectOptions(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RectOptions")
+        }
+    }
+    static isRectResult(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RectResult")
+        }
+    }
+    static isRectShape(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RectShape")
+    }
+    static isRectShapeOptions(value: Object | string | number | undefined | boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RectShapeOptions")
+        }
+    }
+    static isRefreshOptions(value: Object | string | number | undefined | boolean, duplicated_refreshing: boolean, duplicated_promptText: boolean, duplicated_builder: boolean, duplicated_refreshingContent: boolean): boolean {
+        if ((!duplicated_refreshing) && (value?.hasOwnProperty("refreshing"))) {
+            return true
+        }
+        else if ((!duplicated_promptText) && (value?.hasOwnProperty("promptText"))) {
+            return true
+        }
+        else if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_refreshingContent) && (value?.hasOwnProperty("refreshingContent"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RefreshOptions")
+        }
+    }
+    static isRefreshStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RefreshStatus.Inactive)) {
+            return true
+        }
+        else if ((value) === (RefreshStatus.Drag)) {
+            return true
+        }
+        else if ((value) === (RefreshStatus.OverDrag)) {
+            return true
+        }
+        else if ((value) === (RefreshStatus.Refresh)) {
+            return true
+        }
+        else if ((value) === (RefreshStatus.Done)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RefreshStatus")
+        }
+    }
+    static isRelateType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RelateType.FILL)) {
+            return true
+        }
+        else if ((value) === (RelateType.FIT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RelateType")
+        }
+    }
+    static isRenderExitReason(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RenderExitReason.ProcessAbnormalTermination)) {
+            return true
+        }
+        else if ((value) === (RenderExitReason.ProcessWasKilled)) {
+            return true
+        }
+        else if ((value) === (RenderExitReason.ProcessCrashed)) {
+            return true
+        }
+        else if ((value) === (RenderExitReason.ProcessOom)) {
+            return true
+        }
+        else if ((value) === (RenderExitReason.ProcessExitUnknown)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderExitReason")
+        }
+    }
+    static isRenderFit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RenderFit.CENTER)) {
+            return true
+        }
+        else if ((value) === (RenderFit.TOP)) {
+            return true
+        }
+        else if ((value) === (RenderFit.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (RenderFit.LEFT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RIGHT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.TOP_LEFT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.TOP_RIGHT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.BOTTOM_LEFT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.BOTTOM_RIGHT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_FILL)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_CONTAIN)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_CONTAIN_TOP_LEFT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_CONTAIN_BOTTOM_RIGHT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_COVER)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_COVER_TOP_LEFT)) {
+            return true
+        }
+        else if ((value) === (RenderFit.RESIZE_COVER_BOTTOM_RIGHT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderFit")
+        }
+    }
+    static isRenderingContextSettings(value: Object | string | number | undefined | boolean, duplicated_antialias: boolean): boolean {
+        if ((!duplicated_antialias) && (value?.hasOwnProperty("antialias"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderingContextSettings")
+        }
+    }
+    static isRenderMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RenderMode.ASYNC_RENDER)) {
+            return true
+        }
+        else if ((value) === (RenderMode.SYNC_RENDER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderMode")
+        }
+    }
+    static isRenderNode(value: Object | string | number | undefined | boolean, duplicated_backgroundColor: boolean, duplicated_clipToFrame: boolean, duplicated_opacity: boolean, duplicated_size: boolean, duplicated_position: boolean, duplicated_frame: boolean, duplicated_pivot: boolean, duplicated_scale: boolean, duplicated_translation: boolean, duplicated_rotation: boolean, duplicated_transform: boolean, duplicated_shadowColor: boolean, duplicated_shadowOffset: boolean, duplicated_label: boolean, duplicated_shadowAlpha: boolean, duplicated_shadowElevation: boolean, duplicated_shadowRadius: boolean, duplicated_borderStyle: boolean, duplicated_borderWidth: boolean, duplicated_borderColor: boolean, duplicated_borderRadius: boolean, duplicated_shapeMask: boolean, duplicated_shapeClip: boolean, duplicated_markNodeGroup: boolean, duplicated_lengthMetricsUnit: boolean): boolean {
+        if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_clipToFrame) && (value?.hasOwnProperty("clipToFrame"))) {
+            return true
+        }
+        else if ((!duplicated_opacity) && (value?.hasOwnProperty("opacity"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else if ((!duplicated_frame) && (value?.hasOwnProperty("frame"))) {
+            return true
+        }
+        else if ((!duplicated_pivot) && (value?.hasOwnProperty("pivot"))) {
+            return true
+        }
+        else if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_translation) && (value?.hasOwnProperty("translation"))) {
+            return true
+        }
+        else if ((!duplicated_rotation) && (value?.hasOwnProperty("rotation"))) {
+            return true
+        }
+        else if ((!duplicated_transform) && (value?.hasOwnProperty("transform"))) {
+            return true
+        }
+        else if ((!duplicated_shadowColor) && (value?.hasOwnProperty("shadowColor"))) {
+            return true
+        }
+        else if ((!duplicated_shadowOffset) && (value?.hasOwnProperty("shadowOffset"))) {
+            return true
+        }
+        else if ((!duplicated_label) && (value?.hasOwnProperty("label"))) {
+            return true
+        }
+        else if ((!duplicated_shadowAlpha) && (value?.hasOwnProperty("shadowAlpha"))) {
+            return true
+        }
+        else if ((!duplicated_shadowElevation) && (value?.hasOwnProperty("shadowElevation"))) {
+            return true
+        }
+        else if ((!duplicated_shadowRadius) && (value?.hasOwnProperty("shadowRadius"))) {
+            return true
+        }
+        else if ((!duplicated_borderStyle) && (value?.hasOwnProperty("borderStyle"))) {
+            return true
+        }
+        else if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_borderColor) && (value?.hasOwnProperty("borderColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else if ((!duplicated_shapeMask) && (value?.hasOwnProperty("shapeMask"))) {
+            return true
+        }
+        else if ((!duplicated_shapeClip) && (value?.hasOwnProperty("shapeClip"))) {
+            return true
+        }
+        else if ((!duplicated_markNodeGroup) && (value?.hasOwnProperty("markNodeGroup"))) {
+            return true
+        }
+        else if ((!duplicated_lengthMetricsUnit) && (value?.hasOwnProperty("lengthMetricsUnit"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderNode")
+        }
+    }
+    static isRenderProcessNotRespondingData(value: Object | string | number | undefined | boolean, duplicated_jsStack: boolean, duplicated_pid: boolean, duplicated_reason: boolean): boolean {
+        if ((!duplicated_jsStack) && (value?.hasOwnProperty("jsStack"))) {
+            return true
+        }
+        else if ((!duplicated_pid) && (value?.hasOwnProperty("pid"))) {
+            return true
+        }
+        else if ((!duplicated_reason) && (value?.hasOwnProperty("reason"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderProcessNotRespondingData")
+        }
+    }
+    static isRenderProcessNotRespondingReason(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RenderProcessNotRespondingReason.INPUT_TIMEOUT)) {
+            return true
+        }
+        else if ((value) === (RenderProcessNotRespondingReason.NAVIGATION_COMMIT_TIMEOUT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RenderProcessNotRespondingReason")
+        }
+    }
+    static isRepeatMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RepeatMode.Repeat)) {
+            return true
+        }
+        else if ((value) === (RepeatMode.Stretch)) {
+            return true
+        }
+        else if ((value) === (RepeatMode.Round)) {
+            return true
+        }
+        else if ((value) === (RepeatMode.Space)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RepeatMode")
+        }
+    }
+    static isReplaceSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_scope: boolean): boolean {
+        if ((!duplicated_scope) && (value?.hasOwnProperty("scope"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ReplaceSymbolEffect")
+        }
+    }
+    static isResizableOptions(value: Object | string | number | undefined | boolean, duplicated_slice: boolean, duplicated_lattice: boolean): boolean {
+        if ((!duplicated_slice) && (value?.hasOwnProperty("slice"))) {
+            return true
+        }
+        else if ((!duplicated_lattice) && (value?.hasOwnProperty("lattice"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ResizableOptions")
+        }
+    }
+    static isResource(value: Object | string | number | undefined | boolean, duplicated_bundleName: boolean, duplicated_moduleName: boolean, duplicated_id: boolean, duplicated_params: boolean, duplicated_type: boolean): boolean {
+        if ((!duplicated_bundleName) && (value?.hasOwnProperty("bundleName"))) {
+            return true
+        }
+        else if ((!duplicated_moduleName) && (value?.hasOwnProperty("moduleName"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_params) && (value?.hasOwnProperty("params"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Resource")
+        }
+    }
+    static isResourceImageAttachmentOptions(value: Object | string | number | undefined | boolean, duplicated_resourceValue: boolean, duplicated_size: boolean, duplicated_verticalAlign: boolean, duplicated_objectFit: boolean, duplicated_layoutStyle: boolean, duplicated_colorFilter: boolean, duplicated_syncLoad: boolean): boolean {
+        if ((!duplicated_resourceValue) && (value?.hasOwnProperty("resourceValue"))) {
+            return true
+        }
+        else if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_verticalAlign) && (value?.hasOwnProperty("verticalAlign"))) {
+            return true
+        }
+        else if ((!duplicated_objectFit) && (value?.hasOwnProperty("objectFit"))) {
+            return true
+        }
+        else if ((!duplicated_layoutStyle) && (value?.hasOwnProperty("layoutStyle"))) {
+            return true
+        }
+        else if ((!duplicated_colorFilter) && (value?.hasOwnProperty("colorFilter"))) {
+            return true
+        }
+        else if ((!duplicated_syncLoad) && (value?.hasOwnProperty("syncLoad"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ResourceImageAttachmentOptions")
+        }
+    }
+    static isResponseType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ResponseType.RightClick)) {
+            return true
+        }
+        else if ((value) === (ResponseType.LongPress)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ResponseType")
+        }
+    }
+    static isRestrictedWorker(value: Object | string | number | undefined | boolean, duplicated_onexit: boolean, duplicated_onerror: boolean, duplicated_onmessage: boolean, duplicated_onmessageerror: boolean): boolean {
+        if ((!duplicated_onexit) && (value?.hasOwnProperty("onexit"))) {
+            return true
+        }
+        else if ((!duplicated_onerror) && (value?.hasOwnProperty("onerror"))) {
+            return true
+        }
+        else if ((!duplicated_onmessage) && (value?.hasOwnProperty("onmessage"))) {
+            return true
+        }
+        else if ((!duplicated_onmessageerror) && (value?.hasOwnProperty("onmessageerror"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RestrictedWorker")
+        }
+    }
+    static isReuseOptions(value: Object | string | number | undefined | boolean, duplicated_reuseId: boolean): boolean {
+        if ((!duplicated_reuseId) && (value?.hasOwnProperty("reuseId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ReuseOptions")
+        }
+    }
+    static isRichEditorBaseController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RichEditorBaseController")
+    }
+    static isRichEditorBuilderSpanOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_dragBackgroundColor: boolean, duplicated_isDragShadowNeeded: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_dragBackgroundColor) && (value?.hasOwnProperty("dragBackgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_isDragShadowNeeded) && (value?.hasOwnProperty("isDragShadowNeeded"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorBuilderSpanOptions")
+        }
+    }
+    static isRichEditorChangeValue(value: Object | string | number | undefined | boolean, duplicated_rangeBefore: boolean, duplicated_replacedSpans: boolean, duplicated_replacedImageSpans: boolean, duplicated_replacedSymbolSpans: boolean): boolean {
+        if ((!duplicated_rangeBefore) && (value?.hasOwnProperty("rangeBefore"))) {
+            return true
+        }
+        else if ((!duplicated_replacedSpans) && (value?.hasOwnProperty("replacedSpans"))) {
+            return true
+        }
+        else if ((!duplicated_replacedImageSpans) && (value?.hasOwnProperty("replacedImageSpans"))) {
+            return true
+        }
+        else if ((!duplicated_replacedSymbolSpans) && (value?.hasOwnProperty("replacedSymbolSpans"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorChangeValue")
+        }
+    }
+    static isRichEditorController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RichEditorController")
+    }
+    static isRichEditorDeleteDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RichEditorDeleteDirection.BACKWARD)) {
+            return true
+        }
+        else if ((value) === (RichEditorDeleteDirection.FORWARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorDeleteDirection")
+        }
+    }
+    static isRichEditorDeleteValue(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_direction: boolean, duplicated_length: boolean, duplicated_richEditorDeleteSpans: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_length) && (value?.hasOwnProperty("length"))) {
+            return true
+        }
+        else if ((!duplicated_richEditorDeleteSpans) && (value?.hasOwnProperty("richEditorDeleteSpans"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorDeleteValue")
+        }
+    }
+    static isRichEditorGesture(value: Object | string | number | undefined | boolean, duplicated_onClick: boolean, duplicated_onLongPress: boolean, duplicated_onDoubleClick: boolean): boolean {
+        if ((!duplicated_onClick) && (value?.hasOwnProperty("onClick"))) {
+            return true
+        }
+        else if ((!duplicated_onLongPress) && (value?.hasOwnProperty("onLongPress"))) {
+            return true
+        }
+        else if ((!duplicated_onDoubleClick) && (value?.hasOwnProperty("onDoubleClick"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorGesture")
+        }
+    }
+    static isRichEditorImageSpanOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_imageStyle: boolean, duplicated_gesture: boolean, duplicated_onHover: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_imageStyle) && (value?.hasOwnProperty("imageStyle"))) {
+            return true
+        }
+        else if ((!duplicated_gesture) && (value?.hasOwnProperty("gesture"))) {
+            return true
+        }
+        else if ((!duplicated_onHover) && (value?.hasOwnProperty("onHover"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorImageSpanOptions")
+        }
+    }
+    static isRichEditorImageSpanResult(value: Object | string | number | undefined | boolean, duplicated_spanPosition: boolean, duplicated_valuePixelMap: boolean, duplicated_valueResourceStr: boolean, duplicated_imageStyle: boolean, duplicated_offsetInSpan: boolean): boolean {
+        if ((!duplicated_spanPosition) && (value?.hasOwnProperty("spanPosition"))) {
+            return true
+        }
+        else if ((!duplicated_imageStyle) && (value?.hasOwnProperty("imageStyle"))) {
+            return true
+        }
+        else if ((!duplicated_offsetInSpan) && (value?.hasOwnProperty("offsetInSpan"))) {
+            return true
+        }
+        else if ((!duplicated_valuePixelMap) && (value?.hasOwnProperty("valuePixelMap"))) {
+            return true
+        }
+        else if ((!duplicated_valueResourceStr) && (value?.hasOwnProperty("valueResourceStr"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorImageSpanResult")
+        }
+    }
+    static isRichEditorImageSpanStyle(value: Object | string | number | undefined | boolean, duplicated_size: boolean, duplicated_verticalAlign: boolean, duplicated_objectFit: boolean, duplicated_layoutStyle: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_verticalAlign) && (value?.hasOwnProperty("verticalAlign"))) {
+            return true
+        }
+        else if ((!duplicated_objectFit) && (value?.hasOwnProperty("objectFit"))) {
+            return true
+        }
+        else if ((!duplicated_layoutStyle) && (value?.hasOwnProperty("layoutStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorImageSpanStyle")
+        }
+    }
+    static isRichEditorImageSpanStyleResult(value: Object | string | number | undefined | boolean, duplicated_size: boolean, duplicated_verticalAlign: boolean, duplicated_objectFit: boolean, duplicated_layoutStyle: boolean): boolean {
+        if ((!duplicated_size) && (value?.hasOwnProperty("size"))) {
+            return true
+        }
+        else if ((!duplicated_verticalAlign) && (value?.hasOwnProperty("verticalAlign"))) {
+            return true
+        }
+        else if ((!duplicated_objectFit) && (value?.hasOwnProperty("objectFit"))) {
+            return true
+        }
+        else if ((!duplicated_layoutStyle) && (value?.hasOwnProperty("layoutStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorImageSpanStyleResult")
+        }
+    }
+    static isRichEditorInsertValue(value: Object | string | number | undefined | boolean, duplicated_insertOffset: boolean, duplicated_insertValue: boolean, duplicated_previewText: boolean): boolean {
+        if ((!duplicated_insertOffset) && (value?.hasOwnProperty("insertOffset"))) {
+            return true
+        }
+        else if ((!duplicated_insertValue) && (value?.hasOwnProperty("insertValue"))) {
+            return true
+        }
+        else if ((!duplicated_previewText) && (value?.hasOwnProperty("previewText"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorInsertValue")
+        }
+    }
+    static isRichEditorLayoutStyle(value: Object | string | number | undefined | boolean, duplicated_margin: boolean, duplicated_borderRadius: boolean): boolean {
+        if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorLayoutStyle")
+        }
+    }
+    static isRichEditorOptions(value: Object | string | number | undefined | boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorOptions")
+        }
+    }
+    static isRichEditorParagraphResult(value: Object | string | number | undefined | boolean, duplicated_style: boolean, duplicated_range: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_range) && (value?.hasOwnProperty("range"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorParagraphResult")
+        }
+    }
+    static isRichEditorParagraphStyle(value: Object | string | number | undefined | boolean, duplicated_textAlign: boolean, duplicated_leadingMargin: boolean, duplicated_wordBreak: boolean, duplicated_lineBreakStrategy: boolean, duplicated_paragraphSpacing: boolean): boolean {
+        if ((!duplicated_textAlign) && (value?.hasOwnProperty("textAlign"))) {
+            return true
+        }
+        else if ((!duplicated_leadingMargin) && (value?.hasOwnProperty("leadingMargin"))) {
+            return true
+        }
+        else if ((!duplicated_wordBreak) && (value?.hasOwnProperty("wordBreak"))) {
+            return true
+        }
+        else if ((!duplicated_lineBreakStrategy) && (value?.hasOwnProperty("lineBreakStrategy"))) {
+            return true
+        }
+        else if ((!duplicated_paragraphSpacing) && (value?.hasOwnProperty("paragraphSpacing"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorParagraphStyle")
+        }
+    }
+    static isRichEditorParagraphStyleOptions(value: Object | string | number | undefined | boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorParagraphStyleOptions")
+        }
+    }
+    static isRichEditorRange(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorRange")
+        }
+    }
+    static isRichEditorResponseType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RichEditorResponseType.RIGHT_CLICK)) {
+            return true
+        }
+        else if ((value) === (RichEditorResponseType.LONG_PRESS)) {
+            return true
+        }
+        else if ((value) === (RichEditorResponseType.SELECT)) {
+            return true
+        }
+        else if ((value) === (RichEditorResponseType.DEFAULT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorResponseType")
+        }
+    }
+    static isRichEditorSelection(value: Object | string | number | undefined | boolean, duplicated_selection: boolean, duplicated_spans: boolean): boolean {
+        if ((!duplicated_selection) && (value?.hasOwnProperty("selection"))) {
+            return true
+        }
+        else if ((!duplicated_spans) && (value?.hasOwnProperty("spans"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorSelection")
+        }
+    }
+    static isRichEditorSpanPosition(value: Object | string | number | undefined | boolean, duplicated_spanIndex: boolean, duplicated_spanRange: boolean): boolean {
+        if ((!duplicated_spanIndex) && (value?.hasOwnProperty("spanIndex"))) {
+            return true
+        }
+        else if ((!duplicated_spanRange) && (value?.hasOwnProperty("spanRange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorSpanPosition")
+        }
+    }
+    static isRichEditorSpanType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RichEditorSpanType.TEXT)) {
+            return true
+        }
+        else if ((value) === (RichEditorSpanType.IMAGE)) {
+            return true
+        }
+        else if ((value) === (RichEditorSpanType.MIXED)) {
+            return true
+        }
+        else if ((value) === (RichEditorSpanType.BUILDER)) {
+            return true
+        }
+        else if ((value) === (RichEditorSpanType.DEFAULT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorSpanType")
+        }
+    }
+    static isRichEditorStyledStringController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RichEditorStyledStringController")
+    }
+    static isRichEditorStyledStringOptions(value: Object | string | number | undefined | boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorStyledStringOptions")
+        }
+    }
+    static isRichEditorSymbolSpanOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorSymbolSpanOptions")
+        }
+    }
+    static isRichEditorSymbolSpanStyle(value: Object | string | number | undefined | boolean, duplicated_fontSize: boolean, duplicated_fontColor: boolean, duplicated_fontWeight: boolean, duplicated_effectStrategy: boolean, duplicated_renderingStrategy: boolean): boolean {
+        if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_effectStrategy) && (value?.hasOwnProperty("effectStrategy"))) {
+            return true
+        }
+        else if ((!duplicated_renderingStrategy) && (value?.hasOwnProperty("renderingStrategy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorSymbolSpanStyle")
+        }
+    }
+    static isRichEditorTextSpanOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean, duplicated_style: boolean, duplicated_paragraphStyle: boolean, duplicated_gesture: boolean, duplicated_urlStyle: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_paragraphStyle) && (value?.hasOwnProperty("paragraphStyle"))) {
+            return true
+        }
+        else if ((!duplicated_gesture) && (value?.hasOwnProperty("gesture"))) {
+            return true
+        }
+        else if ((!duplicated_urlStyle) && (value?.hasOwnProperty("urlStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorTextSpanOptions")
+        }
+    }
+    static isRichEditorTextSpanResult(value: Object | string | number | undefined | boolean, duplicated_spanPosition: boolean, duplicated_value: boolean, duplicated_textStyle: boolean, duplicated_offsetInSpan: boolean, duplicated_symbolSpanStyle: boolean, duplicated_valueResource: boolean, duplicated_paragraphStyle: boolean, duplicated_previewText: boolean, duplicated_urlStyle: boolean): boolean {
+        if ((!duplicated_spanPosition) && (value?.hasOwnProperty("spanPosition"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_textStyle) && (value?.hasOwnProperty("textStyle"))) {
+            return true
+        }
+        else if ((!duplicated_offsetInSpan) && (value?.hasOwnProperty("offsetInSpan"))) {
+            return true
+        }
+        else if ((!duplicated_symbolSpanStyle) && (value?.hasOwnProperty("symbolSpanStyle"))) {
+            return true
+        }
+        else if ((!duplicated_valueResource) && (value?.hasOwnProperty("valueResource"))) {
+            return true
+        }
+        else if ((!duplicated_paragraphStyle) && (value?.hasOwnProperty("paragraphStyle"))) {
+            return true
+        }
+        else if ((!duplicated_previewText) && (value?.hasOwnProperty("previewText"))) {
+            return true
+        }
+        else if ((!duplicated_urlStyle) && (value?.hasOwnProperty("urlStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorTextSpanResult")
+        }
+    }
+    static isRichEditorTextStyle(value: Object | string | number | undefined | boolean, duplicated_fontColor: boolean, duplicated_fontSize: boolean, duplicated_fontStyle: boolean, duplicated_fontWeight: boolean, duplicated_fontFamily: boolean, duplicated_decoration: boolean, duplicated_textShadow: boolean, duplicated_letterSpacing: boolean, duplicated_lineHeight: boolean, duplicated_halfLeading: boolean, duplicated_fontFeature: boolean, duplicated_textBackgroundStyle: boolean): boolean {
+        if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_decoration) && (value?.hasOwnProperty("decoration"))) {
+            return true
+        }
+        else if ((!duplicated_textShadow) && (value?.hasOwnProperty("textShadow"))) {
+            return true
+        }
+        else if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_lineHeight) && (value?.hasOwnProperty("lineHeight"))) {
+            return true
+        }
+        else if ((!duplicated_halfLeading) && (value?.hasOwnProperty("halfLeading"))) {
+            return true
+        }
+        else if ((!duplicated_fontFeature) && (value?.hasOwnProperty("fontFeature"))) {
+            return true
+        }
+        else if ((!duplicated_textBackgroundStyle) && (value?.hasOwnProperty("textBackgroundStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorTextStyle")
+        }
+    }
+    static isRichEditorTextStyleResult(value: Object | string | number | undefined | boolean, duplicated_fontColor: boolean, duplicated_fontSize: boolean, duplicated_fontStyle: boolean, duplicated_fontWeight: boolean, duplicated_fontFamily: boolean, duplicated_decoration: boolean, duplicated_textShadow: boolean, duplicated_letterSpacing: boolean, duplicated_lineHeight: boolean, duplicated_halfLeading: boolean, duplicated_fontFeature: boolean, duplicated_textBackgroundStyle: boolean): boolean {
+        if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_decoration) && (value?.hasOwnProperty("decoration"))) {
+            return true
+        }
+        else if ((!duplicated_textShadow) && (value?.hasOwnProperty("textShadow"))) {
+            return true
+        }
+        else if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_lineHeight) && (value?.hasOwnProperty("lineHeight"))) {
+            return true
+        }
+        else if ((!duplicated_halfLeading) && (value?.hasOwnProperty("halfLeading"))) {
+            return true
+        }
+        else if ((!duplicated_fontFeature) && (value?.hasOwnProperty("fontFeature"))) {
+            return true
+        }
+        else if ((!duplicated_textBackgroundStyle) && (value?.hasOwnProperty("textBackgroundStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorTextStyleResult")
+        }
+    }
+    static isRichEditorUpdateImageSpanStyleOptions(value: Object | string | number | undefined | boolean, duplicated_imageStyle: boolean): boolean {
+        if ((!duplicated_imageStyle) && (value?.hasOwnProperty("imageStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorUpdateImageSpanStyleOptions")
+        }
+    }
+    static isRichEditorUpdateSymbolSpanStyleOptions(value: Object | string | number | undefined | boolean, duplicated_symbolStyle: boolean): boolean {
+        if ((!duplicated_symbolStyle) && (value?.hasOwnProperty("symbolStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorUpdateSymbolSpanStyleOptions")
+        }
+    }
+    static isRichEditorUpdateTextSpanStyleOptions(value: Object | string | number | undefined | boolean, duplicated_textStyle: boolean, duplicated_urlStyle: boolean): boolean {
+        if ((!duplicated_textStyle) && (value?.hasOwnProperty("textStyle"))) {
+            return true
+        }
+        else if ((!duplicated_urlStyle) && (value?.hasOwnProperty("urlStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorUpdateTextSpanStyleOptions")
+        }
+    }
+    static isRichEditorUrlStyle(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RichEditorUrlStyle")
+        }
+    }
+    static isRingStyleOptions(value: Object | string | number | undefined | boolean, duplicated_strokeWidth: boolean, duplicated_shadow: boolean, duplicated_status: boolean): boolean {
+        if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_status) && (value?.hasOwnProperty("status"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RingStyleOptions")
+        }
+    }
+    static isRootSceneSession(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RootSceneSession")
+    }
+    static isRotateOptions(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean, duplicated_centerX: boolean, duplicated_centerY: boolean, duplicated_centerZ: boolean, duplicated_perspective: boolean, duplicated_angle: boolean): boolean {
+        if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else if ((!duplicated_centerX) && (value?.hasOwnProperty("centerX"))) {
+            return true
+        }
+        else if ((!duplicated_centerY) && (value?.hasOwnProperty("centerY"))) {
+            return true
+        }
+        else if ((!duplicated_centerZ) && (value?.hasOwnProperty("centerZ"))) {
+            return true
+        }
+        else if ((!duplicated_perspective) && (value?.hasOwnProperty("perspective"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RotateOptions")
+        }
+    }
+    static isRotateResult(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean, duplicated_centerX: boolean, duplicated_centerY: boolean, duplicated_angle: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else if ((!duplicated_centerX) && (value?.hasOwnProperty("centerX"))) {
+            return true
+        }
+        else if ((!duplicated_centerY) && (value?.hasOwnProperty("centerY"))) {
+            return true
+        }
+        else if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RotateResult")
+        }
+    }
+    static isRotationGesture(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RotationGesture")
+    }
+    static isRotationGestureEvent(value: Object | string | number | undefined | boolean, duplicated_angle: boolean): boolean {
+        if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RotationGestureEvent")
+        }
+    }
+    static isRotationGestureHandlerOptions(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_angle: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RotationGestureHandlerOptions")
+        }
+    }
+    static isRotationRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RotationRecognizer")
+    }
+    static isRoundedRectOptions(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof RoundedRectOptions")
+    }
+    static isRoundRect(value: Object | string | number | undefined | boolean, duplicated_rect: boolean, duplicated_corners: boolean): boolean {
+        if ((!duplicated_rect) && (value?.hasOwnProperty("rect"))) {
+            return true
+        }
+        else if ((!duplicated_corners) && (value?.hasOwnProperty("corners"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RoundRect")
+        }
+    }
+    static isRoundRectShapeOptions(value: Object | string | number | undefined | boolean, duplicated_radiusWidth: boolean, duplicated_radiusHeight: boolean): boolean {
+        if ((!duplicated_radiusWidth) && (value?.hasOwnProperty("radiusWidth"))) {
+            return true
+        }
+        else if ((!duplicated_radiusHeight) && (value?.hasOwnProperty("radiusHeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RoundRectShapeOptions")
+        }
+    }
+    static isRouteMapConfig(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_pageSourceFile: boolean, duplicated_data: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_pageSourceFile) && (value?.hasOwnProperty("pageSourceFile"))) {
+            return true
+        }
+        else if ((!duplicated_data) && (value?.hasOwnProperty("data"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RouteMapConfig")
+        }
+    }
+    static isRouteType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (RouteType.None)) {
+            return true
+        }
+        else if ((value) === (RouteType.Push)) {
+            return true
+        }
+        else if ((value) === (RouteType.Pop)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RouteType")
+        }
+    }
+    static isRowOptions(value: Object | string | number | undefined | boolean, duplicated_space: boolean): boolean {
+        if ((!duplicated_space) && (value?.hasOwnProperty("space"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RowOptions")
+        }
+    }
+    static isRowOptionsV2(value: Object | string | number | undefined | boolean, duplicated__stub: boolean): boolean {
+        if ((!duplicated__stub) && (value?.hasOwnProperty("_stub"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RowOptionsV2")
+        }
+    }
+    static isRRect(value: Object | string | number | undefined | boolean, duplicated_left: boolean, duplicated_top: boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_top) && (value?.hasOwnProperty("top"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof RRect")
+        }
+    }
+    static isSafeAreaEdge(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SafeAreaEdge.TOP)) {
+            return true
+        }
+        else if ((value) === (SafeAreaEdge.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (SafeAreaEdge.START)) {
+            return true
+        }
+        else if ((value) === (SafeAreaEdge.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SafeAreaEdge")
+        }
+    }
+    static isSafeAreaType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SafeAreaType.SYSTEM)) {
+            return true
+        }
+        else if ((value) === (SafeAreaType.CUTOUT)) {
+            return true
+        }
+        else if ((value) === (SafeAreaType.KEYBOARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SafeAreaType")
+        }
+    }
+    static isSaveButtonOnClickResult(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SaveButtonOnClickResult.SUCCESS)) {
+            return true
+        }
+        else if ((value) === (SaveButtonOnClickResult.TEMPORARY_AUTHORIZATION_FAILED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SaveButtonOnClickResult")
+        }
+    }
+    static isSaveDescription(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SaveDescription.DOWNLOAD)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.DOWNLOAD_FILE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.SAVE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.SAVE_IMAGE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.SAVE_FILE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.DOWNLOAD_AND_SHARE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.RECEIVE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.CONTINUE_TO_RECEIVE)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.SAVE_TO_GALLERY)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.EXPORT_TO_GALLERY)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.QUICK_SAVE_TO_GALLERY)) {
+            return true
+        }
+        else if ((value) === (SaveDescription.RESAVE_TO_GALLERY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SaveDescription")
+        }
+    }
+    static isSaveIconStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SaveIconStyle.FULL_FILLED)) {
+            return true
+        }
+        else if ((value) === (SaveIconStyle.LINES)) {
+            return true
+        }
+        else if ((value) === (SaveIconStyle.PICTURE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SaveIconStyle")
+        }
+    }
+    static isScaleOptions(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean, duplicated_centerX: boolean, duplicated_centerY: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else if ((!duplicated_centerX) && (value?.hasOwnProperty("centerX"))) {
+            return true
+        }
+        else if ((!duplicated_centerY) && (value?.hasOwnProperty("centerY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScaleOptions")
+        }
+    }
+    static isScaleResult(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean, duplicated_centerX: boolean, duplicated_centerY: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else if ((!duplicated_centerX) && (value?.hasOwnProperty("centerX"))) {
+            return true
+        }
+        else if ((!duplicated_centerY) && (value?.hasOwnProperty("centerY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScaleResult")
+        }
+    }
+    static isScaleSymbolEffect(value: Object | string | number | undefined | boolean, duplicated_scope: boolean, duplicated_direction: boolean): boolean {
+        if ((!duplicated_scope) && (value?.hasOwnProperty("scope"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScaleSymbolEffect")
+        }
+    }
+    static isScene(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof Scene")
+    }
+    static isScreenCaptureConfig(value: Object | string | number | undefined | boolean, duplicated_captureMode: boolean): boolean {
+        if ((!duplicated_captureMode) && (value?.hasOwnProperty("captureMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScreenCaptureConfig")
+        }
+    }
+    static isScreenCaptureHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ScreenCaptureHandler")
+    }
+    static isScriptItem(value: Object | string | number | undefined | boolean, duplicated_script: boolean, duplicated_scriptRules: boolean): boolean {
+        if ((!duplicated_script) && (value?.hasOwnProperty("script"))) {
+            return true
+        }
+        else if ((!duplicated_scriptRules) && (value?.hasOwnProperty("scriptRules"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScriptItem")
+        }
+    }
+    static isScrollableBarModeOptions(value: Object | string | number | undefined | boolean, duplicated_margin: boolean, duplicated_nonScrollableLayoutStyle: boolean): boolean {
+        if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else if ((!duplicated_nonScrollableLayoutStyle) && (value?.hasOwnProperty("nonScrollableLayoutStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollableBarModeOptions")
+        }
+    }
+    static isScrollableTargetInfo(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ScrollableTargetInfo")
+    }
+    static isScrollAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollAlign.START)) {
+            return true
+        }
+        else if ((value) === (ScrollAlign.CENTER)) {
+            return true
+        }
+        else if ((value) === (ScrollAlign.END)) {
+            return true
+        }
+        else if ((value) === (ScrollAlign.AUTO)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollAlign")
+        }
+    }
+    static isScrollAnimationOptions(value: Object | string | number | undefined | boolean, duplicated_duration: boolean, duplicated_curve: boolean, duplicated_canOverScroll: boolean): boolean {
+        if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else if ((!duplicated_curve) && (value?.hasOwnProperty("curve"))) {
+            return true
+        }
+        else if ((!duplicated_canOverScroll) && (value?.hasOwnProperty("canOverScroll"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollAnimationOptions")
+        }
+    }
+    static isScrollBarDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollBarDirection.Vertical)) {
+            return true
+        }
+        else if ((value) === (ScrollBarDirection.Horizontal)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollBarDirection")
+        }
+    }
+    static isScrollBarOptions(value: Object | string | number | undefined | boolean, duplicated_scroller: boolean, duplicated_direction: boolean, duplicated_state: boolean): boolean {
+        if ((!duplicated_scroller) && (value?.hasOwnProperty("scroller"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_state) && (value?.hasOwnProperty("state"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollBarOptions")
+        }
+    }
+    static isScrollDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollDirection.Vertical)) {
+            return true
+        }
+        else if ((value) === (ScrollDirection.Horizontal)) {
+            return true
+        }
+        else if ((value) === (ScrollDirection.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollDirection")
+        }
+    }
+    static isScrollEdgeOptions(value: Object | string | number | undefined | boolean, duplicated_velocity: boolean): boolean {
+        if ((!duplicated_velocity) && (value?.hasOwnProperty("velocity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollEdgeOptions")
+        }
+    }
+    static isScroller(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof Scroller")
+    }
+    static isScrollMotion(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ScrollMotion")
+    }
+    static isScrollOptions(value: Object | string | number | undefined | boolean, duplicated_xOffset: boolean, duplicated_yOffset: boolean, duplicated_animation: boolean): boolean {
+        if ((!duplicated_xOffset) && (value?.hasOwnProperty("xOffset"))) {
+            return true
+        }
+        else if ((!duplicated_yOffset) && (value?.hasOwnProperty("yOffset"))) {
+            return true
+        }
+        else if ((!duplicated_animation) && (value?.hasOwnProperty("animation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollOptions")
+        }
+    }
+    static isScrollPageOptions(value: Object | string | number | undefined | boolean, duplicated_next: boolean, duplicated_animation: boolean): boolean {
+        if ((!duplicated_next) && (value?.hasOwnProperty("next"))) {
+            return true
+        }
+        else if ((!duplicated_animation) && (value?.hasOwnProperty("animation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollPageOptions")
+        }
+    }
+    static isScrollResult(value: Object | string | number | undefined | boolean, duplicated_offsetRemain: boolean): boolean {
+        if ((!duplicated_offsetRemain) && (value?.hasOwnProperty("offsetRemain"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollResult")
+        }
+    }
+    static isScrollSizeMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollSizeMode.FOLLOW_DETENT)) {
+            return true
+        }
+        else if ((value) === (ScrollSizeMode.CONTINUOUS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollSizeMode")
+        }
+    }
+    static isScrollSnapAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollSnapAlign.NONE)) {
+            return true
+        }
+        else if ((value) === (ScrollSnapAlign.START)) {
+            return true
+        }
+        else if ((value) === (ScrollSnapAlign.CENTER)) {
+            return true
+        }
+        else if ((value) === (ScrollSnapAlign.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollSnapAlign")
+        }
+    }
+    static isScrollSnapOptions(value: Object | string | number | undefined | boolean, duplicated_snapAlign: boolean, duplicated_snapPagination: boolean, duplicated_enableSnapToStart: boolean, duplicated_enableSnapToEnd: boolean): boolean {
+        if ((!duplicated_snapAlign) && (value?.hasOwnProperty("snapAlign"))) {
+            return true
+        }
+        else if ((!duplicated_snapPagination) && (value?.hasOwnProperty("snapPagination"))) {
+            return true
+        }
+        else if ((!duplicated_enableSnapToStart) && (value?.hasOwnProperty("enableSnapToStart"))) {
+            return true
+        }
+        else if ((!duplicated_enableSnapToEnd) && (value?.hasOwnProperty("enableSnapToEnd"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollSnapOptions")
+        }
+    }
+    static isScrollSource(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollSource.DRAG)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.FLING)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.EDGE_EFFECT)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.OTHER_USER_INPUT)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.SCROLL_BAR)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.SCROLL_BAR_FLING)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.SCROLLER)) {
+            return true
+        }
+        else if ((value) === (ScrollSource.SCROLLER_ANIMATION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollSource")
+        }
+    }
+    static isScrollState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ScrollState.Idle)) {
+            return true
+        }
+        else if ((value) === (ScrollState.Scroll)) {
+            return true
+        }
+        else if ((value) === (ScrollState.Fling)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollState")
+        }
+    }
+    static isScrollToIndexOptions(value: Object | string | number | undefined | boolean, duplicated_extraOffset: boolean): boolean {
+        if ((!duplicated_extraOffset) && (value?.hasOwnProperty("extraOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ScrollToIndexOptions")
+        }
+    }
+    static isSearchButtonOptions(value: Object | string | number | undefined | boolean, duplicated_fontSize: boolean, duplicated_fontColor: boolean, duplicated_autoDisable: boolean): boolean {
+        if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_autoDisable) && (value?.hasOwnProperty("autoDisable"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SearchButtonOptions")
+        }
+    }
+    static isSearchController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SearchController")
+    }
+    static isSearchOptions(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_placeholder: boolean, duplicated_icon: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_placeholder) && (value?.hasOwnProperty("placeholder"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SearchOptions")
+        }
+    }
+    static isSearchType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SearchType.NORMAL)) {
+            return true
+        }
+        else if ((value) === (SearchType.NUMBER)) {
+            return true
+        }
+        else if ((value) === (SearchType.PHONE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (SearchType.EMAIL)) {
+            return true
+        }
+        else if ((value) === (SearchType.NUMBER_DECIMAL)) {
+            return true
+        }
+        else if ((value) === (SearchType.URL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SearchType")
+        }
+    }
+    static isSectionOptions(value: Object | string | number | undefined | boolean, duplicated_itemsCount: boolean, duplicated_crossCount: boolean, duplicated_onGetItemMainSizeByIndex: boolean, duplicated_columnsGap: boolean, duplicated_rowsGap: boolean, duplicated_margin: boolean): boolean {
+        if ((!duplicated_itemsCount) && (value?.hasOwnProperty("itemsCount"))) {
+            return true
+        }
+        else if ((!duplicated_crossCount) && (value?.hasOwnProperty("crossCount"))) {
+            return true
+        }
+        else if ((!duplicated_onGetItemMainSizeByIndex) && (value?.hasOwnProperty("onGetItemMainSizeByIndex"))) {
+            return true
+        }
+        else if ((!duplicated_columnsGap) && (value?.hasOwnProperty("columnsGap"))) {
+            return true
+        }
+        else if ((!duplicated_rowsGap) && (value?.hasOwnProperty("rowsGap"))) {
+            return true
+        }
+        else if ((!duplicated_margin) && (value?.hasOwnProperty("margin"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SectionOptions")
+        }
+    }
+    static isSecurityComponentLayoutDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SecurityComponentLayoutDirection.HORIZONTAL)) {
+            return true
+        }
+        else if ((value) === (SecurityComponentLayoutDirection.VERTICAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SecurityComponentLayoutDirection")
+        }
+    }
+    static isSeekMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SeekMode.PreviousKeyframe)) {
+            return true
+        }
+        else if ((value) === (SeekMode.NextKeyframe)) {
+            return true
+        }
+        else if ((value) === (SeekMode.ClosestKeyframe)) {
+            return true
+        }
+        else if ((value) === (SeekMode.Accurate)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SeekMode")
+        }
+    }
+    static isSelectedMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SelectedMode.INDICATOR)) {
+            return true
+        }
+        else if ((value) === (SelectedMode.BOARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectedMode")
+        }
+    }
+    static isSelectionMenuOptions(value: Object | string | number | undefined | boolean, duplicated_onAppear: boolean, duplicated_onDisappear: boolean, duplicated_menuType: boolean, duplicated_onMenuShow: boolean, duplicated_onMenuHide: boolean, duplicated_previewMenuOptions: boolean): boolean {
+        if ((!duplicated_onAppear) && (value?.hasOwnProperty("onAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDisappear) && (value?.hasOwnProperty("onDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_menuType) && (value?.hasOwnProperty("menuType"))) {
+            return true
+        }
+        else if ((!duplicated_onMenuShow) && (value?.hasOwnProperty("onMenuShow"))) {
+            return true
+        }
+        else if ((!duplicated_onMenuHide) && (value?.hasOwnProperty("onMenuHide"))) {
+            return true
+        }
+        else if ((!duplicated_previewMenuOptions) && (value?.hasOwnProperty("previewMenuOptions"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectionMenuOptions")
+        }
+    }
+    static isSelectionMenuOptionsExt(value: Object | string | number | undefined | boolean, duplicated_onAppear: boolean, duplicated_onDisappear: boolean, duplicated_preview: boolean, duplicated_menuType: boolean): boolean {
+        if ((!duplicated_onAppear) && (value?.hasOwnProperty("onAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDisappear) && (value?.hasOwnProperty("onDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_preview) && (value?.hasOwnProperty("preview"))) {
+            return true
+        }
+        else if ((!duplicated_menuType) && (value?.hasOwnProperty("menuType"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectionMenuOptionsExt")
+        }
+    }
+    static isSelectionOptions(value: Object | string | number | undefined | boolean, duplicated_menuPolicy: boolean): boolean {
+        if ((!duplicated_menuPolicy) && (value?.hasOwnProperty("menuPolicy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectionOptions")
+        }
+    }
+    static isSelectOption(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_icon: boolean, duplicated_symbolIcon: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolIcon) && (value?.hasOwnProperty("symbolIcon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectOption")
+        }
+    }
+    static isSelectStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SelectStatus.All)) {
+            return true
+        }
+        else if ((value) === (SelectStatus.Part)) {
+            return true
+        }
+        else if ((value) === (SelectStatus.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SelectStatus")
+        }
+    }
+    static isShadowOptions(value: Object | string | number | undefined | boolean, duplicated_radius: boolean, duplicated_type: boolean, duplicated_color: boolean, duplicated_offsetX: boolean, duplicated_offsetY: boolean, duplicated_fill: boolean): boolean {
+        if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_offsetX) && (value?.hasOwnProperty("offsetX"))) {
+            return true
+        }
+        else if ((!duplicated_offsetY) && (value?.hasOwnProperty("offsetY"))) {
+            return true
+        }
+        else if ((!duplicated_fill) && (value?.hasOwnProperty("fill"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ShadowOptions")
+        }
+    }
+    static isShadowStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ShadowStyle.OUTER_DEFAULT_XS)) {
+            return true
+        }
+        else if ((value) === (ShadowStyle.OUTER_DEFAULT_SM)) {
+            return true
+        }
+        else if ((value) === (ShadowStyle.OUTER_DEFAULT_MD)) {
+            return true
+        }
+        else if ((value) === (ShadowStyle.OUTER_DEFAULT_LG)) {
+            return true
+        }
+        else if ((value) === (ShadowStyle.OUTER_FLOATING_SM)) {
+            return true
+        }
+        else if ((value) === (ShadowStyle.OUTER_FLOATING_MD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ShadowStyle")
+        }
+    }
+    static isShadowType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ShadowType.COLOR)) {
+            return true
+        }
+        else if ((value) === (ShadowType.BLUR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ShadowType")
+        }
+    }
+    static isShapeClip(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ShapeClip")
+    }
+    static isShapeMask(value: Object | string | number | undefined | boolean, duplicated_fillColor: boolean, duplicated_strokeColor: boolean, duplicated_strokeWidth: boolean): boolean {
+        if ((!duplicated_fillColor) && (value?.hasOwnProperty("fillColor"))) {
+            return true
+        }
+        else if ((!duplicated_strokeColor) && (value?.hasOwnProperty("strokeColor"))) {
+            return true
+        }
+        else if ((!duplicated_strokeWidth) && (value?.hasOwnProperty("strokeWidth"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ShapeMask")
+        }
+    }
+    static isShapeSize(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ShapeSize")
+        }
+    }
+    static isSharedTransitionEffectType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SharedTransitionEffectType.Static)) {
+            return true
+        }
+        else if ((value) === (SharedTransitionEffectType.Exchange)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SharedTransitionEffectType")
+        }
+    }
+    static issharedTransitionOptions(value: Object | string | number | undefined | boolean, duplicated_duration: boolean, duplicated_curve: boolean, duplicated_delay: boolean, duplicated_motionPath: boolean, duplicated_zIndex: boolean, duplicated_type: boolean): boolean {
+        if ((!duplicated_duration) && (value?.hasOwnProperty("duration"))) {
+            return true
+        }
+        else if ((!duplicated_curve) && (value?.hasOwnProperty("curve"))) {
+            return true
+        }
+        else if ((!duplicated_delay) && (value?.hasOwnProperty("delay"))) {
+            return true
+        }
+        else if ((!duplicated_motionPath) && (value?.hasOwnProperty("motionPath"))) {
+            return true
+        }
+        else if ((!duplicated_zIndex) && (value?.hasOwnProperty("zIndex"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof sharedTransitionOptions")
+        }
+    }
+    static isSheetDismiss(value: Object | string | number | undefined | boolean, duplicated_dismiss: boolean): boolean {
+        if ((!duplicated_dismiss) && (value?.hasOwnProperty("dismiss"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetDismiss")
+        }
+    }
+    static isSheetKeyboardAvoidMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SheetKeyboardAvoidMode.NONE)) {
+            return true
+        }
+        else if ((value) === (SheetKeyboardAvoidMode.TRANSLATE_AND_RESIZE)) {
+            return true
+        }
+        else if ((value) === (SheetKeyboardAvoidMode.RESIZE_ONLY)) {
+            return true
+        }
+        else if ((value) === (SheetKeyboardAvoidMode.TRANSLATE_AND_SCROLL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetKeyboardAvoidMode")
+        }
+    }
+    static isSheetMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SheetMode.OVERLAY)) {
+            return true
+        }
+        else if ((value) === (SheetMode.EMBEDDED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetMode")
+        }
+    }
+    static isSheetOptions(value: Object | string | number | undefined | boolean, duplicated_height: boolean, duplicated_dragBar: boolean, duplicated_maskColor: boolean, duplicated_detents: boolean, duplicated_blurStyle: boolean, duplicated_showClose: boolean, duplicated_preferType: boolean, duplicated_title: boolean, duplicated_shouldDismiss: boolean, duplicated_onWillDismiss: boolean, duplicated_onWillSpringBackWhenDismiss: boolean, duplicated_enableOutsideInteractive: boolean, duplicated_width: boolean, duplicated_borderWidth: boolean, duplicated_borderColor: boolean, duplicated_borderStyle: boolean, duplicated_shadow: boolean, duplicated_onHeightDidChange: boolean, duplicated_mode: boolean, duplicated_scrollSizeMode: boolean, duplicated_onDetentsDidChange: boolean, duplicated_onWidthDidChange: boolean, duplicated_onTypeDidChange: boolean, duplicated_uiContext: boolean, duplicated_keyboardAvoidMode: boolean, duplicated_enableHoverMode: boolean, duplicated_hoverModeArea: boolean, duplicated_offset: boolean, duplicated_effectEdge: boolean, duplicated_radius: boolean, duplicated_detentSelection: boolean, duplicated_showInSubWindow: boolean, duplicated_placement: boolean, duplicated_placementOnTarget: boolean): boolean {
+        if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_dragBar) && (value?.hasOwnProperty("dragBar"))) {
+            return true
+        }
+        else if ((!duplicated_maskColor) && (value?.hasOwnProperty("maskColor"))) {
+            return true
+        }
+        else if ((!duplicated_detents) && (value?.hasOwnProperty("detents"))) {
+            return true
+        }
+        else if ((!duplicated_blurStyle) && (value?.hasOwnProperty("blurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_showClose) && (value?.hasOwnProperty("showClose"))) {
+            return true
+        }
+        else if ((!duplicated_preferType) && (value?.hasOwnProperty("preferType"))) {
+            return true
+        }
+        else if ((!duplicated_title) && (value?.hasOwnProperty("title"))) {
+            return true
+        }
+        else if ((!duplicated_shouldDismiss) && (value?.hasOwnProperty("shouldDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDismiss) && (value?.hasOwnProperty("onWillDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_onWillSpringBackWhenDismiss) && (value?.hasOwnProperty("onWillSpringBackWhenDismiss"))) {
+            return true
+        }
+        else if ((!duplicated_enableOutsideInteractive) && (value?.hasOwnProperty("enableOutsideInteractive"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_borderWidth) && (value?.hasOwnProperty("borderWidth"))) {
+            return true
+        }
+        else if ((!duplicated_borderColor) && (value?.hasOwnProperty("borderColor"))) {
+            return true
+        }
+        else if ((!duplicated_borderStyle) && (value?.hasOwnProperty("borderStyle"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_onHeightDidChange) && (value?.hasOwnProperty("onHeightDidChange"))) {
+            return true
+        }
+        else if ((!duplicated_mode) && (value?.hasOwnProperty("mode"))) {
+            return true
+        }
+        else if ((!duplicated_scrollSizeMode) && (value?.hasOwnProperty("scrollSizeMode"))) {
+            return true
+        }
+        else if ((!duplicated_onDetentsDidChange) && (value?.hasOwnProperty("onDetentsDidChange"))) {
+            return true
+        }
+        else if ((!duplicated_onWidthDidChange) && (value?.hasOwnProperty("onWidthDidChange"))) {
+            return true
+        }
+        else if ((!duplicated_onTypeDidChange) && (value?.hasOwnProperty("onTypeDidChange"))) {
+            return true
+        }
+        else if ((!duplicated_uiContext) && (value?.hasOwnProperty("uiContext"))) {
+            return true
+        }
+        else if ((!duplicated_keyboardAvoidMode) && (value?.hasOwnProperty("keyboardAvoidMode"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_hoverModeArea) && (value?.hasOwnProperty("hoverModeArea"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_effectEdge) && (value?.hasOwnProperty("effectEdge"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else if ((!duplicated_detentSelection) && (value?.hasOwnProperty("detentSelection"))) {
+            return true
+        }
+        else if ((!duplicated_showInSubWindow) && (value?.hasOwnProperty("showInSubWindow"))) {
+            return true
+        }
+        else if ((!duplicated_placement) && (value?.hasOwnProperty("placement"))) {
+            return true
+        }
+        else if ((!duplicated_placementOnTarget) && (value?.hasOwnProperty("placementOnTarget"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetOptions")
+        }
+    }
+    static isSheetSize(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SheetSize.MEDIUM)) {
+            return true
+        }
+        else if ((value) === (SheetSize.LARGE)) {
+            return true
+        }
+        else if ((value) === (SheetSize.FIT_CONTENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetSize")
+        }
+    }
+    static isSheetTitleOptions(value: Object | string | number | undefined | boolean, duplicated_title: boolean, duplicated_subtitle: boolean): boolean {
+        if ((!duplicated_title) && (value?.hasOwnProperty("title"))) {
+            return true
+        }
+        else if ((!duplicated_subtitle) && (value?.hasOwnProperty("subtitle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetTitleOptions")
+        }
+    }
+    static isSheetType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SheetType.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (SheetType.CENTER)) {
+            return true
+        }
+        else if ((value) === (SheetType.POPUP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SheetType")
+        }
+    }
+    static isSideBarContainerType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SideBarContainerType.Embed)) {
+            return true
+        }
+        else if ((value) === (SideBarContainerType.Overlay)) {
+            return true
+        }
+        else if ((value) === (SideBarContainerType.AUTO)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SideBarContainerType")
+        }
+    }
+    static isSideBarPosition(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SideBarPosition.Start)) {
+            return true
+        }
+        else if ((value) === (SideBarPosition.End)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SideBarPosition")
+        }
+    }
+    static isSize(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Size")
+        }
+    }
+    static isSizeOptions(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SizeOptions")
+        }
+    }
+    static isSizeResult(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SizeResult")
+        }
+    }
+    static isSlideEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SlideEffect.Left)) {
+            return true
+        }
+        else if ((value) === (SlideEffect.Right)) {
+            return true
+        }
+        else if ((value) === (SlideEffect.Top)) {
+            return true
+        }
+        else if ((value) === (SlideEffect.Bottom)) {
+            return true
+        }
+        else if ((value) === (SlideEffect.START)) {
+            return true
+        }
+        else if ((value) === (SlideEffect.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SlideEffect")
+        }
+    }
+    static isSlideRange(value: Object | string | number | undefined | boolean, duplicated_from: boolean, duplicated_to: boolean): boolean {
+        if ((!duplicated_from) && (value?.hasOwnProperty("from"))) {
+            return true
+        }
+        else if ((!duplicated_to) && (value?.hasOwnProperty("to"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SlideRange")
+        }
+    }
+    static isSliderBlockStyle(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_image: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_image) && (value?.hasOwnProperty("image"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderBlockStyle")
+        }
+    }
+    static isSliderBlockType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SliderBlockType.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (SliderBlockType.IMAGE)) {
+            return true
+        }
+        else if ((value) === (SliderBlockType.SHAPE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderBlockType")
+        }
+    }
+    static isSliderChangeMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SliderChangeMode.Begin)) {
+            return true
+        }
+        else if ((value) === (SliderChangeMode.Moving)) {
+            return true
+        }
+        else if ((value) === (SliderChangeMode.End)) {
+            return true
+        }
+        else if ((value) === (SliderChangeMode.Click)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderChangeMode")
+        }
+    }
+    static isSliderConfiguration(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_min: boolean, duplicated_max: boolean, duplicated_step: boolean, duplicated_triggerChange: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_min) && (value?.hasOwnProperty("min"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else if ((!duplicated_step) && (value?.hasOwnProperty("step"))) {
+            return true
+        }
+        else if ((!duplicated_triggerChange) && (value?.hasOwnProperty("triggerChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderConfiguration")
+        }
+    }
+    static isSliderInteraction(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SliderInteraction.SLIDE_AND_CLICK)) {
+            return true
+        }
+        else if ((value) === (SliderInteraction.SLIDE_ONLY)) {
+            return true
+        }
+        else if ((value) === (SliderInteraction.SLIDE_AND_CLICK_UP)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderInteraction")
+        }
+    }
+    static isSliderOptions(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_min: boolean, duplicated_max: boolean, duplicated_step: boolean, duplicated_style: boolean, duplicated_direction: boolean, duplicated_reverse: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_min) && (value?.hasOwnProperty("min"))) {
+            return true
+        }
+        else if ((!duplicated_max) && (value?.hasOwnProperty("max"))) {
+            return true
+        }
+        else if ((!duplicated_step) && (value?.hasOwnProperty("step"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_reverse) && (value?.hasOwnProperty("reverse"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderOptions")
+        }
+    }
+    static isSliderStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SliderStyle.OutSet)) {
+            return true
+        }
+        else if ((value) === (SliderStyle.InSet)) {
+            return true
+        }
+        else if ((value) === (SliderStyle.NONE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SliderStyle")
+        }
+    }
+    static isSnapshotOptions(value: Object | string | number | undefined | boolean, duplicated_scale: boolean, duplicated_waitUntilRenderFinished: boolean): boolean {
+        if ((!duplicated_scale) && (value?.hasOwnProperty("scale"))) {
+            return true
+        }
+        else if ((!duplicated_waitUntilRenderFinished) && (value?.hasOwnProperty("waitUntilRenderFinished"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SnapshotOptions")
+        }
+    }
+    static isSourceTool(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SourceTool.Unknown)) {
+            return true
+        }
+        else if ((value) === (SourceTool.Finger)) {
+            return true
+        }
+        else if ((value) === (SourceTool.Pen)) {
+            return true
+        }
+        else if ((value) === (SourceTool.MOUSE)) {
+            return true
+        }
+        else if ((value) === (SourceTool.TOUCHPAD)) {
+            return true
+        }
+        else if ((value) === (SourceTool.JOYSTICK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SourceTool")
+        }
+    }
+    static isSourceType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SourceType.Unknown)) {
+            return true
+        }
+        else if ((value) === (SourceType.Mouse)) {
+            return true
+        }
+        else if ((value) === (SourceType.TouchScreen)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SourceType")
+        }
+    }
+    static isSpanStyle(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_length: boolean, duplicated_styledKey: boolean, duplicated_styledValue: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_length) && (value?.hasOwnProperty("length"))) {
+            return true
+        }
+        else if ((!duplicated_styledKey) && (value?.hasOwnProperty("styledKey"))) {
+            return true
+        }
+        else if ((!duplicated_styledValue) && (value?.hasOwnProperty("styledValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SpanStyle")
+        }
+    }
+    static isSpringBackAction(value: Object | string | number | undefined | boolean, duplicated_springBack: boolean): boolean {
+        if ((!duplicated_springBack) && (value?.hasOwnProperty("springBack"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SpringBackAction")
+        }
+    }
+    static isSpringMotion(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SpringMotion")
+    }
+    static isSpringProp(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SpringProp")
+    }
+    static isSslError(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SslError.Invalid)) {
+            return true
+        }
+        else if ((value) === (SslError.HostMismatch)) {
+            return true
+        }
+        else if ((value) === (SslError.DateInvalid)) {
+            return true
+        }
+        else if ((value) === (SslError.Untrusted)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SslError")
+        }
+    }
+    static isSslErrorEvent(value: Object | string | number | undefined | boolean, duplicated_handler: boolean, duplicated_error: boolean, duplicated_url: boolean, duplicated_originalUrl: boolean, duplicated_referrer: boolean, duplicated_isFatalError: boolean, duplicated_isMainFrame: boolean): boolean {
+        if ((!duplicated_handler) && (value?.hasOwnProperty("handler"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else if ((!duplicated_originalUrl) && (value?.hasOwnProperty("originalUrl"))) {
+            return true
+        }
+        else if ((!duplicated_referrer) && (value?.hasOwnProperty("referrer"))) {
+            return true
+        }
+        else if ((!duplicated_isFatalError) && (value?.hasOwnProperty("isFatalError"))) {
+            return true
+        }
+        else if ((!duplicated_isMainFrame) && (value?.hasOwnProperty("isMainFrame"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SslErrorEvent")
+        }
+    }
+    static isSslErrorHandler(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SslErrorHandler")
+    }
+    static isStackOptions(value: Object | string | number | undefined | boolean, duplicated_alignContent: boolean): boolean {
+        if ((!duplicated_alignContent) && (value?.hasOwnProperty("alignContent"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StackOptions")
+        }
+    }
+    static isStarStyleOptions(value: Object | string | number | undefined | boolean, duplicated_backgroundUri: boolean, duplicated_foregroundUri: boolean, duplicated_secondaryUri: boolean): boolean {
+        if ((!duplicated_backgroundUri) && (value?.hasOwnProperty("backgroundUri"))) {
+            return true
+        }
+        else if ((!duplicated_foregroundUri) && (value?.hasOwnProperty("foregroundUri"))) {
+            return true
+        }
+        else if ((!duplicated_secondaryUri) && (value?.hasOwnProperty("secondaryUri"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StarStyleOptions")
+        }
+    }
+    static isStateStyles(value: Object | string | number | undefined | boolean, duplicated_normal: boolean, duplicated_pressed: boolean, duplicated_disabled: boolean, duplicated_focused: boolean, duplicated_clicked: boolean, duplicated_selected: boolean): boolean {
+        if ((!duplicated_normal) && (value?.hasOwnProperty("normal"))) {
+            return true
+        }
+        else if ((!duplicated_pressed) && (value?.hasOwnProperty("pressed"))) {
+            return true
+        }
+        else if ((!duplicated_disabled) && (value?.hasOwnProperty("disabled"))) {
+            return true
+        }
+        else if ((!duplicated_focused) && (value?.hasOwnProperty("focused"))) {
+            return true
+        }
+        else if ((!duplicated_clicked) && (value?.hasOwnProperty("clicked"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StateStyles")
+        }
+    }
+    static isStepperOptions(value: Object | string | number | undefined | boolean, duplicated_index: boolean): boolean {
+        if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StepperOptions")
+        }
+    }
+    static isStickyStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (StickyStyle.None)) {
+            return true
+        }
+        else if ((value) === (StickyStyle.Header)) {
+            return true
+        }
+        else if ((value) === (StickyStyle.Footer)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StickyStyle")
+        }
+    }
+    static isStyledString(value: Object | string | number | undefined | boolean, duplicated_length: boolean): boolean {
+        if ((!duplicated_length) && (value?.hasOwnProperty("length"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StyledString")
+        }
+    }
+    static isStyledStringChangedListener(value: Object | string | number | undefined | boolean, duplicated_onWillChange: boolean, duplicated_onDidChange: boolean): boolean {
+        if ((!duplicated_onWillChange) && (value?.hasOwnProperty("onWillChange"))) {
+            return true
+        }
+        else if ((!duplicated_onDidChange) && (value?.hasOwnProperty("onDidChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StyledStringChangedListener")
+        }
+    }
+    static isStyledStringChangeValue(value: Object | string | number | undefined | boolean, duplicated_range: boolean, duplicated_replacementString: boolean, duplicated_previewText: boolean): boolean {
+        if ((!duplicated_range) && (value?.hasOwnProperty("range"))) {
+            return true
+        }
+        else if ((!duplicated_replacementString) && (value?.hasOwnProperty("replacementString"))) {
+            return true
+        }
+        else if ((!duplicated_previewText) && (value?.hasOwnProperty("previewText"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StyledStringChangeValue")
+        }
+    }
+    static isStyledStringController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof StyledStringController")
+    }
+    static isStyledStringKey(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (StyledStringKey.FONT)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.DECORATION)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.BASELINE_OFFSET)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.LETTER_SPACING)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.TEXT_SHADOW)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.LINE_HEIGHT)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.BACKGROUND_COLOR)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.URL)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.GESTURE)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.PARAGRAPH_STYLE)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.IMAGE)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.CUSTOM_SPAN)) {
+            return true
+        }
+        else if ((value) === (StyledStringKey.USER_DATA)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StyledStringKey")
+        }
+    }
+    static isStyleOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_length: boolean, duplicated_styledKey: boolean, duplicated_styledValue: boolean): boolean {
+        if ((!duplicated_styledKey) && (value?.hasOwnProperty("styledKey"))) {
+            return true
+        }
+        else if ((!duplicated_styledValue) && (value?.hasOwnProperty("styledValue"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_length) && (value?.hasOwnProperty("length"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof StyleOptions")
+        }
+    }
+    static isSubMenuExpandingMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SubMenuExpandingMode.SIDE_EXPAND)) {
+            return true
+        }
+        else if ((value) === (SubMenuExpandingMode.EMBEDDED_EXPAND)) {
+            return true
+        }
+        else if ((value) === (SubMenuExpandingMode.STACK_EXPAND)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SubMenuExpandingMode")
+        }
+    }
+    static isSubmitEvent(value: Object | string | number | undefined | boolean, duplicated_text: boolean): boolean {
+        if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SubmitEvent")
+        }
+    }
+    static isSubTabBarIndicatorStyle(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_height: boolean, duplicated_width: boolean, duplicated_borderRadius: boolean, duplicated_marginTop: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_borderRadius) && (value?.hasOwnProperty("borderRadius"))) {
+            return true
+        }
+        else if ((!duplicated_marginTop) && (value?.hasOwnProperty("marginTop"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SubTabBarIndicatorStyle")
+        }
+    }
+    static isSubTabBarStyle(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SubTabBarStyle")
+    }
+    static isSurfaceRect(value: Object | string | number | undefined | boolean, duplicated_offsetX: boolean, duplicated_offsetY: boolean, duplicated_surfaceWidth: boolean, duplicated_surfaceHeight: boolean): boolean {
+        if ((!duplicated_surfaceWidth) && (value?.hasOwnProperty("surfaceWidth"))) {
+            return true
+        }
+        else if ((!duplicated_surfaceHeight) && (value?.hasOwnProperty("surfaceHeight"))) {
+            return true
+        }
+        else if ((!duplicated_offsetX) && (value?.hasOwnProperty("offsetX"))) {
+            return true
+        }
+        else if ((!duplicated_offsetY) && (value?.hasOwnProperty("offsetY"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SurfaceRect")
+        }
+    }
+    static isSurfaceRotationOptions(value: Object | string | number | undefined | boolean, duplicated_lock: boolean): boolean {
+        if ((!duplicated_lock) && (value?.hasOwnProperty("lock"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SurfaceRotationOptions")
+        }
+    }
+    static isSweepGradientOptions(value: Object | string | number | undefined | boolean, duplicated_center: boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_rotation: boolean, duplicated_colors: boolean, duplicated_repeating: boolean): boolean {
+        if ((!duplicated_center) && (value?.hasOwnProperty("center"))) {
+            return true
+        }
+        else if ((!duplicated_colors) && (value?.hasOwnProperty("colors"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_rotation) && (value?.hasOwnProperty("rotation"))) {
+            return true
+        }
+        else if ((!duplicated_repeating) && (value?.hasOwnProperty("repeating"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SweepGradientOptions")
+        }
+    }
+    static isSwipeActionItem(value: Object | string | number | undefined | boolean, duplicated_builder: boolean, duplicated_builderComponent: boolean, duplicated_actionAreaDistance: boolean, duplicated_onAction: boolean, duplicated_onEnterActionArea: boolean, duplicated_onExitActionArea: boolean, duplicated_onStateChange: boolean): boolean {
+        if ((!duplicated_builder) && (value?.hasOwnProperty("builder"))) {
+            return true
+        }
+        else if ((!duplicated_builderComponent) && (value?.hasOwnProperty("builderComponent"))) {
+            return true
+        }
+        else if ((!duplicated_actionAreaDistance) && (value?.hasOwnProperty("actionAreaDistance"))) {
+            return true
+        }
+        else if ((!duplicated_onAction) && (value?.hasOwnProperty("onAction"))) {
+            return true
+        }
+        else if ((!duplicated_onEnterActionArea) && (value?.hasOwnProperty("onEnterActionArea"))) {
+            return true
+        }
+        else if ((!duplicated_onExitActionArea) && (value?.hasOwnProperty("onExitActionArea"))) {
+            return true
+        }
+        else if ((!duplicated_onStateChange) && (value?.hasOwnProperty("onStateChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeActionItem")
+        }
+    }
+    static isSwipeActionOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean, duplicated_edgeEffect: boolean, duplicated_onOffsetChange: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else if ((!duplicated_edgeEffect) && (value?.hasOwnProperty("edgeEffect"))) {
+            return true
+        }
+        else if ((!duplicated_onOffsetChange) && (value?.hasOwnProperty("onOffsetChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeActionOptions")
+        }
+    }
+    static isSwipeActionState(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwipeActionState.COLLAPSED)) {
+            return true
+        }
+        else if ((value) === (SwipeActionState.EXPANDED)) {
+            return true
+        }
+        else if ((value) === (SwipeActionState.ACTIONING)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeActionState")
+        }
+    }
+    static isSwipeDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwipeDirection.None)) {
+            return true
+        }
+        else if ((value) === (SwipeDirection.Horizontal)) {
+            return true
+        }
+        else if ((value) === (SwipeDirection.Vertical)) {
+            return true
+        }
+        else if ((value) === (SwipeDirection.All)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeDirection")
+        }
+    }
+    static isSwipeEdgeEffect(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwipeEdgeEffect.Spring)) {
+            return true
+        }
+        else if ((value) === (SwipeEdgeEffect.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeEdgeEffect")
+        }
+    }
+    static isSwipeGesture(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SwipeGesture")
+    }
+    static isSwipeGestureEvent(value: Object | string | number | undefined | boolean, duplicated_angle: boolean, duplicated_speed: boolean): boolean {
+        if ((!duplicated_angle) && (value?.hasOwnProperty("angle"))) {
+            return true
+        }
+        else if ((!duplicated_speed) && (value?.hasOwnProperty("speed"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeGestureEvent")
+        }
+    }
+    static isSwipeGestureHandlerOptions(value: Object | string | number | undefined | boolean, duplicated_fingers: boolean, duplicated_direction: boolean, duplicated_speed: boolean): boolean {
+        if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else if ((!duplicated_speed) && (value?.hasOwnProperty("speed"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwipeGestureHandlerOptions")
+        }
+    }
+    static isSwiperAnimationEvent(value: Object | string | number | undefined | boolean, duplicated_currentOffset: boolean, duplicated_targetOffset: boolean, duplicated_velocity: boolean): boolean {
+        if ((!duplicated_currentOffset) && (value?.hasOwnProperty("currentOffset"))) {
+            return true
+        }
+        else if ((!duplicated_targetOffset) && (value?.hasOwnProperty("targetOffset"))) {
+            return true
+        }
+        else if ((!duplicated_velocity) && (value?.hasOwnProperty("velocity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperAnimationEvent")
+        }
+    }
+    static isSwiperAnimationMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwiperAnimationMode.NO_ANIMATION)) {
+            return true
+        }
+        else if ((value) === (SwiperAnimationMode.DEFAULT_ANIMATION)) {
+            return true
+        }
+        else if ((value) === (SwiperAnimationMode.FAST_ANIMATION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperAnimationMode")
+        }
+    }
+    static isSwiperAutoFill(value: Object | string | number | undefined | boolean, duplicated_minSize: boolean): boolean {
+        if ((!duplicated_minSize) && (value?.hasOwnProperty("minSize"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperAutoFill")
+        }
+    }
+    static isSwiperContentAnimatedTransition(value: Object | string | number | undefined | boolean, duplicated_timeout: boolean, duplicated_transition: boolean): boolean {
+        if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_timeout) && (value?.hasOwnProperty("timeout"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperContentAnimatedTransition")
+        }
+    }
+    static isSwiperContentTransitionProxy(value: Object | string | number | undefined | boolean, duplicated_selectedIndex: boolean, duplicated_index: boolean, duplicated_position: boolean, duplicated_mainAxisLength: boolean): boolean {
+        if ((!duplicated_selectedIndex) && (value?.hasOwnProperty("selectedIndex"))) {
+            return true
+        }
+        else if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else if ((!duplicated_mainAxisLength) && (value?.hasOwnProperty("mainAxisLength"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperContentTransitionProxy")
+        }
+    }
+    static isSwiperContentWillScrollResult(value: Object | string | number | undefined | boolean, duplicated_currentIndex: boolean, duplicated_comingIndex: boolean, duplicated_offset: boolean): boolean {
+        if ((!duplicated_currentIndex) && (value?.hasOwnProperty("currentIndex"))) {
+            return true
+        }
+        else if ((!duplicated_comingIndex) && (value?.hasOwnProperty("comingIndex"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperContentWillScrollResult")
+        }
+    }
+    static isSwiperController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SwiperController")
+    }
+    static isSwiperDisplayMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwiperDisplayMode.STRETCH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperDisplayMode")
+        }
+    }
+    static isSwipeRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SwipeRecognizer")
+    }
+    static isSwiperNestedScrollMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SwiperNestedScrollMode.SELF_ONLY)) {
+            return true
+        }
+        else if ((value) === (SwiperNestedScrollMode.SELF_FIRST)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwiperNestedScrollMode")
+        }
+    }
+    static isSwitchStyle(value: Object | string | number | undefined | boolean, duplicated_pointRadius: boolean, duplicated_unselectedColor: boolean, duplicated_pointColor: boolean, duplicated_trackBorderRadius: boolean): boolean {
+        if ((!duplicated_pointRadius) && (value?.hasOwnProperty("pointRadius"))) {
+            return true
+        }
+        else if ((!duplicated_unselectedColor) && (value?.hasOwnProperty("unselectedColor"))) {
+            return true
+        }
+        else if ((!duplicated_pointColor) && (value?.hasOwnProperty("pointColor"))) {
+            return true
+        }
+        else if ((!duplicated_trackBorderRadius) && (value?.hasOwnProperty("trackBorderRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SwitchStyle")
+        }
+    }
+    static isSymbolEffect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SymbolEffect")
+    }
+    static isSymbolEffectStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SymbolEffectStrategy.NONE)) {
+            return true
+        }
+        else if ((value) === (SymbolEffectStrategy.SCALE)) {
+            return true
+        }
+        else if ((value) === (SymbolEffectStrategy.HIERARCHICAL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SymbolEffectStrategy")
+        }
+    }
+    static isSymbolGlyphModifier(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof SymbolGlyphModifier")
+    }
+    static isSymbolRenderingStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (SymbolRenderingStrategy.SINGLE)) {
+            return true
+        }
+        else if ((value) === (SymbolRenderingStrategy.MULTIPLE_COLOR)) {
+            return true
+        }
+        else if ((value) === (SymbolRenderingStrategy.MULTIPLE_OPACITY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SymbolRenderingStrategy")
+        }
+    }
+    static isSystemAdaptiveOptions(value: Object | string | number | undefined | boolean, duplicated_disableSystemAdaptation: boolean): boolean {
+        if ((!duplicated_disableSystemAdaptation) && (value?.hasOwnProperty("disableSystemAdaptation"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof SystemAdaptiveOptions")
+        }
+    }
+    static isTabBarIconStyle(value: Object | string | number | undefined | boolean, duplicated_selectedColor: boolean, duplicated_unselectedColor: boolean): boolean {
+        if ((!duplicated_selectedColor) && (value?.hasOwnProperty("selectedColor"))) {
+            return true
+        }
+        else if ((!duplicated_unselectedColor) && (value?.hasOwnProperty("unselectedColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabBarIconStyle")
+        }
+    }
+    static isTabBarLabelStyle(value: Object | string | number | undefined | boolean, duplicated_overflow: boolean, duplicated_maxLines: boolean, duplicated_minFontSize: boolean, duplicated_maxFontSize: boolean, duplicated_heightAdaptivePolicy: boolean, duplicated_font: boolean, duplicated_selectedColor: boolean, duplicated_unselectedColor: boolean): boolean {
+        if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_minFontSize) && (value?.hasOwnProperty("minFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_maxFontSize) && (value?.hasOwnProperty("maxFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_heightAdaptivePolicy) && (value?.hasOwnProperty("heightAdaptivePolicy"))) {
+            return true
+        }
+        else if ((!duplicated_font) && (value?.hasOwnProperty("font"))) {
+            return true
+        }
+        else if ((!duplicated_selectedColor) && (value?.hasOwnProperty("selectedColor"))) {
+            return true
+        }
+        else if ((!duplicated_unselectedColor) && (value?.hasOwnProperty("unselectedColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabBarLabelStyle")
+        }
+    }
+    static isTabBarOptions(value: Object | string | number | undefined | boolean, duplicated_icon: boolean, duplicated_text: boolean): boolean {
+        if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabBarOptions")
+        }
+    }
+    static isTabBarSymbol(value: Object | string | number | undefined | boolean, duplicated_normal: boolean, duplicated_selected: boolean): boolean {
+        if ((!duplicated_normal) && (value?.hasOwnProperty("normal"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabBarSymbol")
+        }
+    }
+    static isTabContentAnimatedTransition(value: Object | string | number | undefined | boolean, duplicated_timeout: boolean, duplicated_transition: boolean): boolean {
+        if ((!duplicated_transition) && (value?.hasOwnProperty("transition"))) {
+            return true
+        }
+        else if ((!duplicated_timeout) && (value?.hasOwnProperty("timeout"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabContentAnimatedTransition")
+        }
+    }
+    static isTabContentTransitionProxy(value: Object | string | number | undefined | boolean, duplicated_from: boolean, duplicated_to: boolean): boolean {
+        if ((!duplicated_from) && (value?.hasOwnProperty("from"))) {
+            return true
+        }
+        else if ((!duplicated_to) && (value?.hasOwnProperty("to"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabContentTransitionProxy")
+        }
+    }
+    static isTabsAnimationEvent(value: Object | string | number | undefined | boolean, duplicated_currentOffset: boolean, duplicated_targetOffset: boolean, duplicated_velocity: boolean): boolean {
+        if ((!duplicated_currentOffset) && (value?.hasOwnProperty("currentOffset"))) {
+            return true
+        }
+        else if ((!duplicated_targetOffset) && (value?.hasOwnProperty("targetOffset"))) {
+            return true
+        }
+        else if ((!duplicated_velocity) && (value?.hasOwnProperty("velocity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabsAnimationEvent")
+        }
+    }
+    static isTabsCacheMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TabsCacheMode.CACHE_BOTH_SIDE)) {
+            return true
+        }
+        else if ((value) === (TabsCacheMode.CACHE_LATEST_SWITCHED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabsCacheMode")
+        }
+    }
+    static isTabsController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TabsController")
+    }
+    static isTabsOptions(value: Object | string | number | undefined | boolean, duplicated_barPosition: boolean, duplicated_index: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_barPosition) && (value?.hasOwnProperty("barPosition"))) {
+            return true
+        }
+        else if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TabsOptions")
+        }
+    }
+    static isTapGestureEvent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TapGestureEvent")
+    }
+    static isTapGestureInterface(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TapGestureInterface")
+    }
+    static isTapGestureParameters(value: Object | string | number | undefined | boolean, duplicated_count: boolean, duplicated_fingers: boolean, duplicated_distanceThreshold: boolean): boolean {
+        if ((!duplicated_count) && (value?.hasOwnProperty("count"))) {
+            return true
+        }
+        else if ((!duplicated_fingers) && (value?.hasOwnProperty("fingers"))) {
+            return true
+        }
+        else if ((!duplicated_distanceThreshold) && (value?.hasOwnProperty("distanceThreshold"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TapGestureParameters")
+        }
+    }
+    static isTapRecognizer(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TapRecognizer")
+    }
+    static isTargetInfo(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_componentId: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_componentId) && (value?.hasOwnProperty("componentId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TargetInfo")
+        }
+    }
+    static isTerminationInfo(value: Object | string | number | undefined | boolean, duplicated_code: boolean, duplicated_want: boolean): boolean {
+        if ((!duplicated_code) && (value?.hasOwnProperty("code"))) {
+            return true
+        }
+        else if ((!duplicated_want) && (value?.hasOwnProperty("want"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TerminationInfo")
+        }
+    }
+    static istext_Affinity(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.Affinity.UPSTREAM)) {
+            return true
+        }
+        else if ((value) === (text.Affinity.DOWNSTREAM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.Affinity")
+        }
+    }
+    static istext_BreakStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.BreakStrategy.GREEDY)) {
+            return true
+        }
+        else if ((value) === (text.BreakStrategy.HIGH_QUALITY)) {
+            return true
+        }
+        else if ((value) === (text.BreakStrategy.BALANCED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.BreakStrategy")
+        }
+    }
+    static istext_Decoration(value: Object | string | number | undefined | boolean, duplicated_textDecoration: boolean, duplicated_color: boolean, duplicated_decorationStyle: boolean, duplicated_decorationThicknessScale: boolean): boolean {
+        if ((!duplicated_textDecoration) && (value?.hasOwnProperty("textDecoration"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_decorationStyle) && (value?.hasOwnProperty("decorationStyle"))) {
+            return true
+        }
+        else if ((!duplicated_decorationThicknessScale) && (value?.hasOwnProperty("decorationThicknessScale"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.Decoration")
+        }
+    }
+    static istext_EllipsisMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.EllipsisMode.START)) {
+            return true
+        }
+        else if ((value) === (text.EllipsisMode.MIDDLE)) {
+            return true
+        }
+        else if ((value) === (text.EllipsisMode.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.EllipsisMode")
+        }
+    }
+    static istext_FontCollection(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.FontCollection")
+    }
+    static istext_FontDescriptor(value: Object | string | number | undefined | boolean, duplicated_path: boolean, duplicated_postScriptName: boolean, duplicated_fullName: boolean, duplicated_fontFamily: boolean, duplicated_fontSubfamily: boolean, duplicated_weight: boolean, duplicated_width: boolean, duplicated_italic: boolean, duplicated_monoSpace: boolean, duplicated_symbolic: boolean): boolean {
+        if ((!duplicated_path) && (value?.hasOwnProperty("path"))) {
+            return true
+        }
+        else if ((!duplicated_postScriptName) && (value?.hasOwnProperty("postScriptName"))) {
+            return true
+        }
+        else if ((!duplicated_fullName) && (value?.hasOwnProperty("fullName"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_fontSubfamily) && (value?.hasOwnProperty("fontSubfamily"))) {
+            return true
+        }
+        else if ((!duplicated_weight) && (value?.hasOwnProperty("weight"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_italic) && (value?.hasOwnProperty("italic"))) {
+            return true
+        }
+        else if ((!duplicated_monoSpace) && (value?.hasOwnProperty("monoSpace"))) {
+            return true
+        }
+        else if ((!duplicated_symbolic) && (value?.hasOwnProperty("symbolic"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontDescriptor")
+        }
+    }
+    static istext_FontFeature(value: Object | string | number | undefined | boolean, duplicated_name: boolean, duplicated_value: boolean): boolean {
+        if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontFeature")
+        }
+    }
+    static istext_FontStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.FontStyle.NORMAL)) {
+            return true
+        }
+        else if ((value) === (text.FontStyle.ITALIC)) {
+            return true
+        }
+        else if ((value) === (text.FontStyle.OBLIQUE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontStyle")
+        }
+    }
+    static istext_FontVariation(value: Object | string | number | undefined | boolean, duplicated_axis: boolean, duplicated_value: boolean): boolean {
+        if ((!duplicated_axis) && (value?.hasOwnProperty("axis"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontVariation")
+        }
+    }
+    static istext_FontWeight(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.FontWeight.W100)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W200)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W300)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W400)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W500)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W600)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W700)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W800)) {
+            return true
+        }
+        else if ((value) === (text.FontWeight.W900)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontWeight")
+        }
+    }
+    static istext_FontWidth(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.FontWidth.ULTRA_CONDENSED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.EXTRA_CONDENSED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.CONDENSED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.SEMI_CONDENSED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.NORMAL)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.SEMI_EXPANDED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.EXPANDED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.EXTRA_EXPANDED)) {
+            return true
+        }
+        else if ((value) === (text.FontWidth.ULTRA_EXPANDED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.FontWidth")
+        }
+    }
+    static istext_LineMetrics(value: Object | string | number | undefined | boolean, duplicated_startIndex: boolean, duplicated_endIndex: boolean, duplicated_ascent: boolean, duplicated_descent: boolean, duplicated_height: boolean, duplicated_width: boolean, duplicated_left: boolean, duplicated_baseline: boolean, duplicated_lineNumber: boolean, duplicated_topHeight: boolean, duplicated_runMetrics: boolean): boolean {
+        if ((!duplicated_startIndex) && (value?.hasOwnProperty("startIndex"))) {
+            return true
+        }
+        else if ((!duplicated_endIndex) && (value?.hasOwnProperty("endIndex"))) {
+            return true
+        }
+        else if ((!duplicated_ascent) && (value?.hasOwnProperty("ascent"))) {
+            return true
+        }
+        else if ((!duplicated_descent) && (value?.hasOwnProperty("descent"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_left) && (value?.hasOwnProperty("left"))) {
+            return true
+        }
+        else if ((!duplicated_baseline) && (value?.hasOwnProperty("baseline"))) {
+            return true
+        }
+        else if ((!duplicated_lineNumber) && (value?.hasOwnProperty("lineNumber"))) {
+            return true
+        }
+        else if ((!duplicated_topHeight) && (value?.hasOwnProperty("topHeight"))) {
+            return true
+        }
+        else if ((!duplicated_runMetrics) && (value?.hasOwnProperty("runMetrics"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.LineMetrics")
+        }
+    }
+    static istext_LineTypeset(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.LineTypeset")
+    }
+    static istext_Paragraph(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.Paragraph")
+    }
+    static istext_ParagraphBuilder(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.ParagraphBuilder")
+    }
+    static istext_ParagraphStyle(value: Object | string | number | undefined | boolean, duplicated_textStyle: boolean, duplicated_textDirection: boolean, duplicated_align: boolean, duplicated_wordBreak: boolean, duplicated_maxLines: boolean, duplicated_breakStrategy: boolean, duplicated_strutStyle: boolean, duplicated_textHeightBehavior: boolean, duplicated_tab: boolean): boolean {
+        if ((!duplicated_textStyle) && (value?.hasOwnProperty("textStyle"))) {
+            return true
+        }
+        else if ((!duplicated_textDirection) && (value?.hasOwnProperty("textDirection"))) {
+            return true
+        }
+        else if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else if ((!duplicated_wordBreak) && (value?.hasOwnProperty("wordBreak"))) {
+            return true
+        }
+        else if ((!duplicated_maxLines) && (value?.hasOwnProperty("maxLines"))) {
+            return true
+        }
+        else if ((!duplicated_breakStrategy) && (value?.hasOwnProperty("breakStrategy"))) {
+            return true
+        }
+        else if ((!duplicated_strutStyle) && (value?.hasOwnProperty("strutStyle"))) {
+            return true
+        }
+        else if ((!duplicated_textHeightBehavior) && (value?.hasOwnProperty("textHeightBehavior"))) {
+            return true
+        }
+        else if ((!duplicated_tab) && (value?.hasOwnProperty("tab"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.ParagraphStyle")
+        }
+    }
+    static istext_PlaceholderAlignment(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.PlaceholderAlignment.OFFSET_AT_BASELINE)) {
+            return true
+        }
+        else if ((value) === (text.PlaceholderAlignment.ABOVE_BASELINE)) {
+            return true
+        }
+        else if ((value) === (text.PlaceholderAlignment.BELOW_BASELINE)) {
+            return true
+        }
+        else if ((value) === (text.PlaceholderAlignment.TOP_OF_ROW_BOX)) {
+            return true
+        }
+        else if ((value) === (text.PlaceholderAlignment.BOTTOM_OF_ROW_BOX)) {
+            return true
+        }
+        else if ((value) === (text.PlaceholderAlignment.CENTER_OF_ROW_BOX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.PlaceholderAlignment")
+        }
+    }
+    static istext_PlaceholderSpan(value: Object | string | number | undefined | boolean, duplicated_width: boolean, duplicated_height: boolean, duplicated_align: boolean, duplicated_baseline: boolean, duplicated_baselineOffset: boolean): boolean {
+        if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_align) && (value?.hasOwnProperty("align"))) {
+            return true
+        }
+        else if ((!duplicated_baseline) && (value?.hasOwnProperty("baseline"))) {
+            return true
+        }
+        else if ((!duplicated_baselineOffset) && (value?.hasOwnProperty("baselineOffset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.PlaceholderSpan")
+        }
+    }
+    static istext_PositionWithAffinity(value: Object | string | number | undefined | boolean, duplicated_position: boolean, duplicated_affinity: boolean): boolean {
+        if ((!duplicated_position) && (value?.hasOwnProperty("position"))) {
+            return true
+        }
+        else if ((!duplicated_affinity) && (value?.hasOwnProperty("affinity"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.PositionWithAffinity")
+        }
+    }
+    static istext_Range(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.Range")
+        }
+    }
+    static istext_RectHeightStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.RectHeightStyle.TIGHT)) {
+            return true
+        }
+        else if ((value) === (text.RectHeightStyle.MAX)) {
+            return true
+        }
+        else if ((value) === (text.RectHeightStyle.INCLUDE_LINE_SPACE_MIDDLE)) {
+            return true
+        }
+        else if ((value) === (text.RectHeightStyle.INCLUDE_LINE_SPACE_TOP)) {
+            return true
+        }
+        else if ((value) === (text.RectHeightStyle.INCLUDE_LINE_SPACE_BOTTOM)) {
+            return true
+        }
+        else if ((value) === (text.RectHeightStyle.STRUT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.RectHeightStyle")
+        }
+    }
+    static istext_RectStyle(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_leftTopRadius: boolean, duplicated_rightTopRadius: boolean, duplicated_rightBottomRadius: boolean, duplicated_leftBottomRadius: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_leftTopRadius) && (value?.hasOwnProperty("leftTopRadius"))) {
+            return true
+        }
+        else if ((!duplicated_rightTopRadius) && (value?.hasOwnProperty("rightTopRadius"))) {
+            return true
+        }
+        else if ((!duplicated_rightBottomRadius) && (value?.hasOwnProperty("rightBottomRadius"))) {
+            return true
+        }
+        else if ((!duplicated_leftBottomRadius) && (value?.hasOwnProperty("leftBottomRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.RectStyle")
+        }
+    }
+    static istext_RectWidthStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.RectWidthStyle.TIGHT)) {
+            return true
+        }
+        else if ((value) === (text.RectWidthStyle.MAX)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.RectWidthStyle")
+        }
+    }
+    static istext_Run(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.Run")
+    }
+    static istext_RunMetrics(value: Object | string | number | undefined | boolean, duplicated_textStyle: boolean, duplicated_fontMetrics: boolean): boolean {
+        if ((!duplicated_textStyle) && (value?.hasOwnProperty("textStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontMetrics) && (value?.hasOwnProperty("fontMetrics"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.RunMetrics")
+        }
+    }
+    static istext_StrutStyle(value: Object | string | number | undefined | boolean, duplicated_fontFamilies: boolean, duplicated_fontStyle: boolean, duplicated_fontWidth: boolean, duplicated_fontWeight: boolean, duplicated_fontSize: boolean, duplicated_height: boolean, duplicated_leading: boolean, duplicated_forceHeight: boolean, duplicated_enabled: boolean, duplicated_heightOverride: boolean, duplicated_halfLeading: boolean): boolean {
+        if ((!duplicated_fontFamilies) && (value?.hasOwnProperty("fontFamilies"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_fontWidth) && (value?.hasOwnProperty("fontWidth"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else if ((!duplicated_leading) && (value?.hasOwnProperty("leading"))) {
+            return true
+        }
+        else if ((!duplicated_forceHeight) && (value?.hasOwnProperty("forceHeight"))) {
+            return true
+        }
+        else if ((!duplicated_enabled) && (value?.hasOwnProperty("enabled"))) {
+            return true
+        }
+        else if ((!duplicated_heightOverride) && (value?.hasOwnProperty("heightOverride"))) {
+            return true
+        }
+        else if ((!duplicated_halfLeading) && (value?.hasOwnProperty("halfLeading"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.StrutStyle")
+        }
+    }
+    static istext_SystemFontType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.SystemFontType.ALL)) {
+            return true
+        }
+        else if ((value) === (text.SystemFontType.GENERIC)) {
+            return true
+        }
+        else if ((value) === (text.SystemFontType.STYLISH)) {
+            return true
+        }
+        else if ((value) === (text.SystemFontType.INSTALLED)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.SystemFontType")
+        }
+    }
+    static istext_TextAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextAlign.LEFT)) {
+            return true
+        }
+        else if ((value) === (text.TextAlign.RIGHT)) {
+            return true
+        }
+        else if ((value) === (text.TextAlign.CENTER)) {
+            return true
+        }
+        else if ((value) === (text.TextAlign.JUSTIFY)) {
+            return true
+        }
+        else if ((value) === (text.TextAlign.START)) {
+            return true
+        }
+        else if ((value) === (text.TextAlign.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextAlign")
+        }
+    }
+    static istext_TextBaseline(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextBaseline.ALPHABETIC)) {
+            return true
+        }
+        else if ((value) === (text.TextBaseline.IDEOGRAPHIC)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextBaseline")
+        }
+    }
+    static istext_TextBox(value: Object | string | number | undefined | boolean, duplicated_rect: boolean, duplicated_direction: boolean): boolean {
+        if ((!duplicated_rect) && (value?.hasOwnProperty("rect"))) {
+            return true
+        }
+        else if ((!duplicated_direction) && (value?.hasOwnProperty("direction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextBox")
+        }
+    }
+    static istext_TextDecorationStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextDecorationStyle.SOLID)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationStyle.DOUBLE)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationStyle.DOTTED)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationStyle.DASHED)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationStyle.WAVY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextDecorationStyle")
+        }
+    }
+    static istext_TextDecorationType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextDecorationType.NONE)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationType.UNDERLINE)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationType.OVERLINE)) {
+            return true
+        }
+        else if ((value) === (text.TextDecorationType.LINE_THROUGH)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextDecorationType")
+        }
+    }
+    static istext_TextDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextDirection.RTL)) {
+            return true
+        }
+        else if ((value) === (text.TextDirection.LTR)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextDirection")
+        }
+    }
+    static istext_TextHeightBehavior(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.TextHeightBehavior.ALL)) {
+            return true
+        }
+        else if ((value) === (text.TextHeightBehavior.DISABLE_FIRST_ASCENT)) {
+            return true
+        }
+        else if ((value) === (text.TextHeightBehavior.DISABLE_LAST_ASCENT)) {
+            return true
+        }
+        else if ((value) === (text.TextHeightBehavior.DISABLE_ALL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextHeightBehavior")
+        }
+    }
+    static istext_TextLine(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof text.TextLine")
+    }
+    static istext_TextShadow(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_point: boolean, duplicated_blurRadius: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_point) && (value?.hasOwnProperty("point"))) {
+            return true
+        }
+        else if ((!duplicated_blurRadius) && (value?.hasOwnProperty("blurRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextShadow")
+        }
+    }
+    static istext_TextStyle(value: Object | string | number | undefined | boolean, duplicated_decoration: boolean, duplicated_color: boolean, duplicated_fontWeight: boolean, duplicated_fontStyle: boolean, duplicated_baseline: boolean, duplicated_fontFamilies: boolean, duplicated_fontSize: boolean, duplicated_letterSpacing: boolean, duplicated_wordSpacing: boolean, duplicated_heightScale: boolean, duplicated_halfLeading: boolean, duplicated_heightOnly: boolean, duplicated_ellipsis: boolean, duplicated_ellipsisMode: boolean, duplicated_locale: boolean, duplicated_baselineShift: boolean, duplicated_fontFeatures: boolean, duplicated_textShadows: boolean, duplicated_backgroundRect: boolean, duplicated_fontVariations: boolean): boolean {
+        if ((!duplicated_decoration) && (value?.hasOwnProperty("decoration"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else if ((!duplicated_baseline) && (value?.hasOwnProperty("baseline"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamilies) && (value?.hasOwnProperty("fontFamilies"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_letterSpacing) && (value?.hasOwnProperty("letterSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_wordSpacing) && (value?.hasOwnProperty("wordSpacing"))) {
+            return true
+        }
+        else if ((!duplicated_heightScale) && (value?.hasOwnProperty("heightScale"))) {
+            return true
+        }
+        else if ((!duplicated_halfLeading) && (value?.hasOwnProperty("halfLeading"))) {
+            return true
+        }
+        else if ((!duplicated_heightOnly) && (value?.hasOwnProperty("heightOnly"))) {
+            return true
+        }
+        else if ((!duplicated_ellipsis) && (value?.hasOwnProperty("ellipsis"))) {
+            return true
+        }
+        else if ((!duplicated_ellipsisMode) && (value?.hasOwnProperty("ellipsisMode"))) {
+            return true
+        }
+        else if ((!duplicated_locale) && (value?.hasOwnProperty("locale"))) {
+            return true
+        }
+        else if ((!duplicated_baselineShift) && (value?.hasOwnProperty("baselineShift"))) {
+            return true
+        }
+        else if ((!duplicated_fontFeatures) && (value?.hasOwnProperty("fontFeatures"))) {
+            return true
+        }
+        else if ((!duplicated_textShadows) && (value?.hasOwnProperty("textShadows"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundRect) && (value?.hasOwnProperty("backgroundRect"))) {
+            return true
+        }
+        else if ((!duplicated_fontVariations) && (value?.hasOwnProperty("fontVariations"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextStyle")
+        }
+    }
+    static istext_TextTab(value: Object | string | number | undefined | boolean, duplicated_alignment: boolean, duplicated_location: boolean): boolean {
+        if ((!duplicated_alignment) && (value?.hasOwnProperty("alignment"))) {
+            return true
+        }
+        else if ((!duplicated_location) && (value?.hasOwnProperty("location"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TextTab")
+        }
+    }
+    static istext_TypographicBounds(value: Object | string | number | undefined | boolean, duplicated_ascent: boolean, duplicated_descent: boolean, duplicated_leading: boolean, duplicated_width: boolean): boolean {
+        if ((!duplicated_ascent) && (value?.hasOwnProperty("ascent"))) {
+            return true
+        }
+        else if ((!duplicated_descent) && (value?.hasOwnProperty("descent"))) {
+            return true
+        }
+        else if ((!duplicated_leading) && (value?.hasOwnProperty("leading"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.TypographicBounds")
+        }
+    }
+    static istext_WordBreak(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (text.WordBreak.NORMAL)) {
+            return true
+        }
+        else if ((value) === (text.WordBreak.BREAK_ALL)) {
+            return true
+        }
+        else if ((value) === (text.WordBreak.BREAK_WORD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof text.WordBreak")
+        }
+    }
+    static isTextAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextAlign.Center)) {
+            return true
+        }
+        else if ((value) === (TextAlign.Start)) {
+            return true
+        }
+        else if ((value) === (TextAlign.End)) {
+            return true
+        }
+        else if ((value) === (TextAlign.JUSTIFY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextAlign")
+        }
+    }
+    static isTextAreaController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextAreaController")
+    }
+    static isTextAreaOptions(value: Object | string | number | undefined | boolean, duplicated_placeholder: boolean, duplicated_text: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_placeholder) && (value?.hasOwnProperty("placeholder"))) {
+            return true
+        }
+        else if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextAreaOptions")
+        }
+    }
+    static isTextAreaType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextAreaType.NORMAL)) {
+            return true
+        }
+        else if ((value) === (TextAreaType.NUMBER)) {
+            return true
+        }
+        else if ((value) === (TextAreaType.PHONE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (TextAreaType.EMAIL)) {
+            return true
+        }
+        else if ((value) === (TextAreaType.NUMBER_DECIMAL)) {
+            return true
+        }
+        else if ((value) === (TextAreaType.URL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextAreaType")
+        }
+    }
+    static isTextBackgroundStyle(value: Object | string | number | undefined | boolean, duplicated_color: boolean, duplicated_radius: boolean): boolean {
+        if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_radius) && (value?.hasOwnProperty("radius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextBackgroundStyle")
+        }
+    }
+    static isTextBaseController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextBaseController")
+    }
+    static isTextCascadePickerRangeContent(value: Object | string | number | undefined | boolean, duplicated_text: boolean, duplicated_children: boolean): boolean {
+        if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else if ((!duplicated_children) && (value?.hasOwnProperty("children"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextCascadePickerRangeContent")
+        }
+    }
+    static isTextCase(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextCase.Normal)) {
+            return true
+        }
+        else if ((value) === (TextCase.LowerCase)) {
+            return true
+        }
+        else if ((value) === (TextCase.UpperCase)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextCase")
+        }
+    }
+    static isTextChangeOptions(value: Object | string | number | undefined | boolean, duplicated_rangeBefore: boolean, duplicated_rangeAfter: boolean, duplicated_oldContent: boolean, duplicated_oldPreviewText: boolean): boolean {
+        if ((!duplicated_rangeBefore) && (value?.hasOwnProperty("rangeBefore"))) {
+            return true
+        }
+        else if ((!duplicated_rangeAfter) && (value?.hasOwnProperty("rangeAfter"))) {
+            return true
+        }
+        else if ((!duplicated_oldContent) && (value?.hasOwnProperty("oldContent"))) {
+            return true
+        }
+        else if ((!duplicated_oldPreviewText) && (value?.hasOwnProperty("oldPreviewText"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextChangeOptions")
+        }
+    }
+    static isTextClockConfiguration(value: Object | string | number | undefined | boolean, duplicated_timeZoneOffset: boolean, duplicated_started: boolean, duplicated_timeValue: boolean): boolean {
+        if ((!duplicated_timeZoneOffset) && (value?.hasOwnProperty("timeZoneOffset"))) {
+            return true
+        }
+        else if ((!duplicated_started) && (value?.hasOwnProperty("started"))) {
+            return true
+        }
+        else if ((!duplicated_timeValue) && (value?.hasOwnProperty("timeValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextClockConfiguration")
+        }
+    }
+    static isTextClockController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextClockController")
+    }
+    static isTextClockOptions(value: Object | string | number | undefined | boolean, duplicated_timeZoneOffset: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_timeZoneOffset) && (value?.hasOwnProperty("timeZoneOffset"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextClockOptions")
+        }
+    }
+    static isTextContentControllerBase(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextContentControllerBase")
+    }
+    static isTextContentControllerOptions(value: Object | string | number | undefined | boolean, duplicated_offset: boolean): boolean {
+        if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextContentControllerOptions")
+        }
+    }
+    static isTextContentStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextContentStyle.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (TextContentStyle.INLINE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextContentStyle")
+        }
+    }
+    static isTextController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextController")
+    }
+    static isTextDataDetectorConfig(value: Object | string | number | undefined | boolean, duplicated_types: boolean, duplicated_onDetectResultUpdate: boolean, duplicated_color: boolean, duplicated_decoration: boolean): boolean {
+        if ((!duplicated_types) && (value?.hasOwnProperty("types"))) {
+            return true
+        }
+        else if ((!duplicated_onDetectResultUpdate) && (value?.hasOwnProperty("onDetectResultUpdate"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_decoration) && (value?.hasOwnProperty("decoration"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDataDetectorConfig")
+        }
+    }
+    static isTextDataDetectorType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextDataDetectorType.PHONE_NUMBER)) {
+            return true
+        }
+        else if ((value) === (TextDataDetectorType.URL)) {
+            return true
+        }
+        else if ((value) === (TextDataDetectorType.EMAIL)) {
+            return true
+        }
+        else if ((value) === (TextDataDetectorType.ADDRESS)) {
+            return true
+        }
+        else if ((value) === (TextDataDetectorType.DATE_TIME)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDataDetectorType")
+        }
+    }
+    static isTextDecorationOptions(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_color: boolean, duplicated_style: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_color) && (value?.hasOwnProperty("color"))) {
+            return true
+        }
+        else if ((!duplicated_style) && (value?.hasOwnProperty("style"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDecorationOptions")
+        }
+    }
+    static isTextDecorationStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextDecorationStyle.SOLID)) {
+            return true
+        }
+        else if ((value) === (TextDecorationStyle.DOUBLE)) {
+            return true
+        }
+        else if ((value) === (TextDecorationStyle.DOTTED)) {
+            return true
+        }
+        else if ((value) === (TextDecorationStyle.DASHED)) {
+            return true
+        }
+        else if ((value) === (TextDecorationStyle.WAVY)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDecorationStyle")
+        }
+    }
+    static isTextDecorationType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextDecorationType.None)) {
+            return true
+        }
+        else if ((value) === (TextDecorationType.Underline)) {
+            return true
+        }
+        else if ((value) === (TextDecorationType.Overline)) {
+            return true
+        }
+        else if ((value) === (TextDecorationType.LineThrough)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDecorationType")
+        }
+    }
+    static isTextDeleteDirection(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextDeleteDirection.BACKWARD)) {
+            return true
+        }
+        else if ((value) === (TextDeleteDirection.FORWARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextDeleteDirection")
+        }
+    }
+    static isTextEditControllerEx(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextEditControllerEx")
+    }
+    static isTextHeightAdaptivePolicy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextHeightAdaptivePolicy.MAX_LINES_FIRST)) {
+            return true
+        }
+        else if ((value) === (TextHeightAdaptivePolicy.MIN_FONT_SIZE_FIRST)) {
+            return true
+        }
+        else if ((value) === (TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextHeightAdaptivePolicy")
+        }
+    }
+    static isTextInputController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextInputController")
+    }
+    static isTextInputOptions(value: Object | string | number | undefined | boolean, duplicated_placeholder: boolean, duplicated_text: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_placeholder) && (value?.hasOwnProperty("placeholder"))) {
+            return true
+        }
+        else if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextInputOptions")
+        }
+    }
+    static isTextInputStyle(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextInputStyle.Default)) {
+            return true
+        }
+        else if ((value) === (TextInputStyle.Inline)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextInputStyle")
+        }
+    }
+    static isTextMarqueeOptions(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_step: boolean, duplicated_loop: boolean, duplicated_fromStart: boolean, duplicated_delay: boolean, duplicated_fadeout: boolean, duplicated_marqueeStartPolicy: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_step) && (value?.hasOwnProperty("step"))) {
+            return true
+        }
+        else if ((!duplicated_loop) && (value?.hasOwnProperty("loop"))) {
+            return true
+        }
+        else if ((!duplicated_fromStart) && (value?.hasOwnProperty("fromStart"))) {
+            return true
+        }
+        else if ((!duplicated_delay) && (value?.hasOwnProperty("delay"))) {
+            return true
+        }
+        else if ((!duplicated_fadeout) && (value?.hasOwnProperty("fadeout"))) {
+            return true
+        }
+        else if ((!duplicated_marqueeStartPolicy) && (value?.hasOwnProperty("marqueeStartPolicy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextMarqueeOptions")
+        }
+    }
+    static isTextMenuController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextMenuController")
+    }
+    static isTextMenuItem(value: Object | string | number | undefined | boolean, duplicated_content: boolean, duplicated_icon: boolean, duplicated_id: boolean, duplicated_labelInfo: boolean): boolean {
+        if ((!duplicated_content) && (value?.hasOwnProperty("content"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_labelInfo) && (value?.hasOwnProperty("labelInfo"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextMenuItem")
+        }
+    }
+    static isTextMenuItemId(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextMenuItemId")
+    }
+    static isTextMenuOptions(value: Object | string | number | undefined | boolean, duplicated_showMode: boolean): boolean {
+        if ((!duplicated_showMode) && (value?.hasOwnProperty("showMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextMenuOptions")
+        }
+    }
+    static isTextMenuShowMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextMenuShowMode.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (TextMenuShowMode.PREFER_WINDOW)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextMenuShowMode")
+        }
+    }
+    static isTextMetrics(value: Object | string | number | undefined | boolean, duplicated_actualBoundingBoxAscent: boolean, duplicated_actualBoundingBoxDescent: boolean, duplicated_actualBoundingBoxLeft: boolean, duplicated_actualBoundingBoxRight: boolean, duplicated_alphabeticBaseline: boolean, duplicated_emHeightAscent: boolean, duplicated_emHeightDescent: boolean, duplicated_fontBoundingBoxAscent: boolean, duplicated_fontBoundingBoxDescent: boolean, duplicated_hangingBaseline: boolean, duplicated_ideographicBaseline: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_actualBoundingBoxAscent) && (value?.hasOwnProperty("actualBoundingBoxAscent"))) {
+            return true
+        }
+        else if ((!duplicated_actualBoundingBoxDescent) && (value?.hasOwnProperty("actualBoundingBoxDescent"))) {
+            return true
+        }
+        else if ((!duplicated_actualBoundingBoxLeft) && (value?.hasOwnProperty("actualBoundingBoxLeft"))) {
+            return true
+        }
+        else if ((!duplicated_actualBoundingBoxRight) && (value?.hasOwnProperty("actualBoundingBoxRight"))) {
+            return true
+        }
+        else if ((!duplicated_alphabeticBaseline) && (value?.hasOwnProperty("alphabeticBaseline"))) {
+            return true
+        }
+        else if ((!duplicated_emHeightAscent) && (value?.hasOwnProperty("emHeightAscent"))) {
+            return true
+        }
+        else if ((!duplicated_emHeightDescent) && (value?.hasOwnProperty("emHeightDescent"))) {
+            return true
+        }
+        else if ((!duplicated_fontBoundingBoxAscent) && (value?.hasOwnProperty("fontBoundingBoxAscent"))) {
+            return true
+        }
+        else if ((!duplicated_fontBoundingBoxDescent) && (value?.hasOwnProperty("fontBoundingBoxDescent"))) {
+            return true
+        }
+        else if ((!duplicated_hangingBaseline) && (value?.hasOwnProperty("hangingBaseline"))) {
+            return true
+        }
+        else if ((!duplicated_ideographicBaseline) && (value?.hasOwnProperty("ideographicBaseline"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextMetrics")
+        }
+    }
+    static isTextModifier(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextModifier")
+    }
+    static isTextOptions(value: Object | string | number | undefined | boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextOptions")
+        }
+    }
+    static isTextOverflow(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextOverflow.None)) {
+            return true
+        }
+        else if ((value) === (TextOverflow.Clip)) {
+            return true
+        }
+        else if ((value) === (TextOverflow.Ellipsis)) {
+            return true
+        }
+        else if ((value) === (TextOverflow.MARQUEE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextOverflow")
+        }
+    }
+    static isTextOverflowOptions(value: Object | string | number | undefined | boolean, duplicated_overflow: boolean): boolean {
+        if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextOverflowOptions")
+        }
+    }
+    static isTextPickerDialog(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextPickerDialog")
+    }
+    static isTextPickerDialogOptions(value: Object | string | number | undefined | boolean, duplicated_defaultPickerItemHeight: boolean, duplicated_canLoop: boolean, duplicated_disappearTextStyle: boolean, duplicated_textStyle: boolean, duplicated_acceptButtonStyle: boolean, duplicated_cancelButtonStyle: boolean, duplicated_selectedTextStyle: boolean, duplicated_disableTextStyleAnimation: boolean, duplicated_defaultTextStyle: boolean, duplicated_onAccept: boolean, duplicated_onCancel: boolean, duplicated_onChange: boolean, duplicated_onScrollStop: boolean, duplicated_onEnterSelectedArea: boolean, duplicated_maskRect: boolean, duplicated_alignment: boolean, duplicated_offset: boolean, duplicated_backgroundColor: boolean, duplicated_backgroundBlurStyle: boolean, duplicated_backgroundBlurStyleOptions: boolean, duplicated_backgroundEffect: boolean, duplicated_onDidAppear: boolean, duplicated_onDidDisappear: boolean, duplicated_onWillAppear: boolean, duplicated_onWillDisappear: boolean, duplicated_shadow: boolean, duplicated_enableHoverMode: boolean, duplicated_hoverModeArea: boolean, duplicated_enableHapticFeedback: boolean): boolean {
+        if ((!duplicated_defaultPickerItemHeight) && (value?.hasOwnProperty("defaultPickerItemHeight"))) {
+            return true
+        }
+        else if ((!duplicated_canLoop) && (value?.hasOwnProperty("canLoop"))) {
+            return true
+        }
+        else if ((!duplicated_disappearTextStyle) && (value?.hasOwnProperty("disappearTextStyle"))) {
+            return true
+        }
+        else if ((!duplicated_textStyle) && (value?.hasOwnProperty("textStyle"))) {
+            return true
+        }
+        else if ((!duplicated_acceptButtonStyle) && (value?.hasOwnProperty("acceptButtonStyle"))) {
+            return true
+        }
+        else if ((!duplicated_cancelButtonStyle) && (value?.hasOwnProperty("cancelButtonStyle"))) {
+            return true
+        }
+        else if ((!duplicated_selectedTextStyle) && (value?.hasOwnProperty("selectedTextStyle"))) {
+            return true
+        }
+        else if ((!duplicated_disableTextStyleAnimation) && (value?.hasOwnProperty("disableTextStyleAnimation"))) {
+            return true
+        }
+        else if ((!duplicated_defaultTextStyle) && (value?.hasOwnProperty("defaultTextStyle"))) {
+            return true
+        }
+        else if ((!duplicated_onAccept) && (value?.hasOwnProperty("onAccept"))) {
+            return true
+        }
+        else if ((!duplicated_onCancel) && (value?.hasOwnProperty("onCancel"))) {
+            return true
+        }
+        else if ((!duplicated_onChange) && (value?.hasOwnProperty("onChange"))) {
+            return true
+        }
+        else if ((!duplicated_onScrollStop) && (value?.hasOwnProperty("onScrollStop"))) {
+            return true
+        }
+        else if ((!duplicated_onEnterSelectedArea) && (value?.hasOwnProperty("onEnterSelectedArea"))) {
+            return true
+        }
+        else if ((!duplicated_maskRect) && (value?.hasOwnProperty("maskRect"))) {
+            return true
+        }
+        else if ((!duplicated_alignment) && (value?.hasOwnProperty("alignment"))) {
+            return true
+        }
+        else if ((!duplicated_offset) && (value?.hasOwnProperty("offset"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundColor) && (value?.hasOwnProperty("backgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyle) && (value?.hasOwnProperty("backgroundBlurStyle"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundBlurStyleOptions) && (value?.hasOwnProperty("backgroundBlurStyleOptions"))) {
+            return true
+        }
+        else if ((!duplicated_backgroundEffect) && (value?.hasOwnProperty("backgroundEffect"))) {
+            return true
+        }
+        else if ((!duplicated_onDidAppear) && (value?.hasOwnProperty("onDidAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onDidDisappear) && (value?.hasOwnProperty("onDidDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillAppear) && (value?.hasOwnProperty("onWillAppear"))) {
+            return true
+        }
+        else if ((!duplicated_onWillDisappear) && (value?.hasOwnProperty("onWillDisappear"))) {
+            return true
+        }
+        else if ((!duplicated_shadow) && (value?.hasOwnProperty("shadow"))) {
+            return true
+        }
+        else if ((!duplicated_enableHoverMode) && (value?.hasOwnProperty("enableHoverMode"))) {
+            return true
+        }
+        else if ((!duplicated_hoverModeArea) && (value?.hasOwnProperty("hoverModeArea"))) {
+            return true
+        }
+        else if ((!duplicated_enableHapticFeedback) && (value?.hasOwnProperty("enableHapticFeedback"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextPickerDialogOptions")
+        }
+    }
+    static isTextPickerOptions(value: Object | string | number | undefined | boolean, duplicated_range: boolean, duplicated_value: boolean, duplicated_selected: boolean, duplicated_columnWidths: boolean): boolean {
+        if ((!duplicated_range) && (value?.hasOwnProperty("range"))) {
+            return true
+        }
+        else if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_columnWidths) && (value?.hasOwnProperty("columnWidths"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextPickerOptions")
+        }
+    }
+    static isTextPickerRangeContent(value: Object | string | number | undefined | boolean, duplicated_icon: boolean, duplicated_text: boolean): boolean {
+        if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_text) && (value?.hasOwnProperty("text"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextPickerRangeContent")
+        }
+    }
+    static isTextPickerResult(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_index: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextPickerResult")
+        }
+    }
+    static isTextPickerTextStyle(value: Object | string | number | undefined | boolean, duplicated_minFontSize: boolean, duplicated_maxFontSize: boolean, duplicated_overflow: boolean): boolean {
+        if ((!duplicated_minFontSize) && (value?.hasOwnProperty("minFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_maxFontSize) && (value?.hasOwnProperty("maxFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_overflow) && (value?.hasOwnProperty("overflow"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextPickerTextStyle")
+        }
+    }
+    static isTextRange(value: Object | string | number | undefined | boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextRange")
+        }
+    }
+    static isTextResponseType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextResponseType.RIGHT_CLICK)) {
+            return true
+        }
+        else if ((value) === (TextResponseType.LONG_PRESS)) {
+            return true
+        }
+        else if ((value) === (TextResponseType.SELECT)) {
+            return true
+        }
+        else if ((value) === (TextResponseType.DEFAULT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextResponseType")
+        }
+    }
+    static isTextSelectableMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextSelectableMode.SELECTABLE_UNFOCUSABLE)) {
+            return true
+        }
+        else if ((value) === (TextSelectableMode.SELECTABLE_FOCUSABLE)) {
+            return true
+        }
+        else if ((value) === (TextSelectableMode.UNSELECTABLE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextSelectableMode")
+        }
+    }
+    static isTextShadowStyle(value: Object | string | number | undefined | boolean, duplicated_textShadow: boolean): boolean {
+        if ((!duplicated_textShadow) && (value?.hasOwnProperty("textShadow"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextShadowStyle")
+        }
+    }
+    static isTextSpanType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TextSpanType.TEXT)) {
+            return true
+        }
+        else if ((value) === (TextSpanType.IMAGE)) {
+            return true
+        }
+        else if ((value) === (TextSpanType.MIXED)) {
+            return true
+        }
+        else if ((value) === (TextSpanType.DEFAULT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextSpanType")
+        }
+    }
+    static isTextStyle(value: Object | string | number | undefined | boolean, duplicated_fontColor: boolean, duplicated_fontFamily: boolean, duplicated_fontSize: boolean, duplicated_fontWeight: boolean, duplicated_fontStyle: boolean): boolean {
+        if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextStyle")
+        }
+    }
+    static isTextStyleInterface(value: Object | string | number | undefined | boolean, duplicated_fontColor: boolean, duplicated_fontFamily: boolean, duplicated_fontSize: boolean, duplicated_fontWeight: boolean, duplicated_fontStyle: boolean): boolean {
+        if ((!duplicated_fontColor) && (value?.hasOwnProperty("fontColor"))) {
+            return true
+        }
+        else if ((!duplicated_fontFamily) && (value?.hasOwnProperty("fontFamily"))) {
+            return true
+        }
+        else if ((!duplicated_fontSize) && (value?.hasOwnProperty("fontSize"))) {
+            return true
+        }
+        else if ((!duplicated_fontWeight) && (value?.hasOwnProperty("fontWeight"))) {
+            return true
+        }
+        else if ((!duplicated_fontStyle) && (value?.hasOwnProperty("fontStyle"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextStyleInterface")
+        }
+    }
+    static isTextTimerConfiguration(value: Object | string | number | undefined | boolean, duplicated_count: boolean, duplicated_isCountDown: boolean, duplicated_started: boolean, duplicated_elapsedTime: boolean): boolean {
+        if ((!duplicated_count) && (value?.hasOwnProperty("count"))) {
+            return true
+        }
+        else if ((!duplicated_isCountDown) && (value?.hasOwnProperty("isCountDown"))) {
+            return true
+        }
+        else if ((!duplicated_started) && (value?.hasOwnProperty("started"))) {
+            return true
+        }
+        else if ((!duplicated_elapsedTime) && (value?.hasOwnProperty("elapsedTime"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextTimerConfiguration")
+        }
+    }
+    static isTextTimerController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TextTimerController")
+    }
+    static isTextTimerOptions(value: Object | string | number | undefined | boolean, duplicated_isCountDown: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_isCountDown) && (value?.hasOwnProperty("isCountDown"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TextTimerOptions")
+        }
+    }
+    static isThemeColorMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ThemeColorMode.SYSTEM)) {
+            return true
+        }
+        else if ((value) === (ThemeColorMode.LIGHT)) {
+            return true
+        }
+        else if ((value) === (ThemeColorMode.DARK)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ThemeColorMode")
+        }
+    }
+    static isThemeControl(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof ThemeControl")
+    }
+    static isThreatType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ThreatType.THREAT_ILLEGAL)) {
+            return true
+        }
+        else if ((value) === (ThreatType.THREAT_FRAUD)) {
+            return true
+        }
+        else if ((value) === (ThreatType.THREAT_RISK)) {
+            return true
+        }
+        else if ((value) === (ThreatType.THREAT_WARNING)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ThreatType")
+        }
+    }
+    static isTimePickerDialog(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TimePickerDialog")
+    }
+    static isTimePickerFormat(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TimePickerFormat.HOUR_MINUTE)) {
+            return true
+        }
+        else if ((value) === (TimePickerFormat.HOUR_MINUTE_SECOND)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TimePickerFormat")
+        }
+    }
+    static isTimePickerOptions(value: Object | string | number | undefined | boolean, duplicated_selected: boolean, duplicated_format: boolean, duplicated_start: boolean, duplicated_end: boolean): boolean {
+        if ((!duplicated_selected) && (value?.hasOwnProperty("selected"))) {
+            return true
+        }
+        else if ((!duplicated_format) && (value?.hasOwnProperty("format"))) {
+            return true
+        }
+        else if ((!duplicated_start) && (value?.hasOwnProperty("start"))) {
+            return true
+        }
+        else if ((!duplicated_end) && (value?.hasOwnProperty("end"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TimePickerOptions")
+        }
+    }
+    static isTimePickerResult(value: Object | string | number | undefined | boolean, duplicated_hour: boolean, duplicated_minute: boolean, duplicated_second: boolean): boolean {
+        if ((!duplicated_hour) && (value?.hasOwnProperty("hour"))) {
+            return true
+        }
+        else if ((!duplicated_minute) && (value?.hasOwnProperty("minute"))) {
+            return true
+        }
+        else if ((!duplicated_second) && (value?.hasOwnProperty("second"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TimePickerResult")
+        }
+    }
+    static isTipsOptions(value: Object | string | number | undefined | boolean, duplicated_appearingTime: boolean, duplicated_disappearingTime: boolean, duplicated_appearingTimeWithContinuousOperation: boolean, duplicated_disappearingTimeWithContinuousOperation: boolean, duplicated_enableArrow: boolean, duplicated_arrowPointPosition: boolean, duplicated_arrowWidth: boolean, duplicated_arrowHeight: boolean): boolean {
+        if ((!duplicated_appearingTime) && (value?.hasOwnProperty("appearingTime"))) {
+            return true
+        }
+        else if ((!duplicated_disappearingTime) && (value?.hasOwnProperty("disappearingTime"))) {
+            return true
+        }
+        else if ((!duplicated_appearingTimeWithContinuousOperation) && (value?.hasOwnProperty("appearingTimeWithContinuousOperation"))) {
+            return true
+        }
+        else if ((!duplicated_disappearingTimeWithContinuousOperation) && (value?.hasOwnProperty("disappearingTimeWithContinuousOperation"))) {
+            return true
+        }
+        else if ((!duplicated_enableArrow) && (value?.hasOwnProperty("enableArrow"))) {
+            return true
+        }
+        else if ((!duplicated_arrowPointPosition) && (value?.hasOwnProperty("arrowPointPosition"))) {
+            return true
+        }
+        else if ((!duplicated_arrowWidth) && (value?.hasOwnProperty("arrowWidth"))) {
+            return true
+        }
+        else if ((!duplicated_arrowHeight) && (value?.hasOwnProperty("arrowHeight"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TipsOptions")
+        }
+    }
+    static isTitleHeight(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TitleHeight.MainOnly)) {
+            return true
+        }
+        else if ((value) === (TitleHeight.MainWithSub)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TitleHeight")
+        }
+    }
+    static isTodayStyle(value: Object | string | number | undefined | boolean, duplicated_focusedDayColor: boolean, duplicated_focusedLunarColor: boolean, duplicated_focusedAreaBackgroundColor: boolean, duplicated_focusedAreaRadius: boolean): boolean {
+        if ((!duplicated_focusedDayColor) && (value?.hasOwnProperty("focusedDayColor"))) {
+            return true
+        }
+        else if ((!duplicated_focusedLunarColor) && (value?.hasOwnProperty("focusedLunarColor"))) {
+            return true
+        }
+        else if ((!duplicated_focusedAreaBackgroundColor) && (value?.hasOwnProperty("focusedAreaBackgroundColor"))) {
+            return true
+        }
+        else if ((!duplicated_focusedAreaRadius) && (value?.hasOwnProperty("focusedAreaRadius"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TodayStyle")
+        }
+    }
+    static isToggleConfiguration(value: Object | string | number | undefined | boolean, duplicated_isOn: boolean, duplicated_toggleEnabled: boolean, duplicated_triggerChange: boolean): boolean {
+        if ((!duplicated_isOn) && (value?.hasOwnProperty("isOn"))) {
+            return true
+        }
+        else if ((!duplicated_toggleEnabled) && (value?.hasOwnProperty("toggleEnabled"))) {
+            return true
+        }
+        else if ((!duplicated_triggerChange) && (value?.hasOwnProperty("triggerChange"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ToggleConfiguration")
+        }
+    }
+    static isToggleOptions(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_isOn: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_isOn) && (value?.hasOwnProperty("isOn"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ToggleOptions")
+        }
+    }
+    static isToggleType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ToggleType.Checkbox)) {
+            return true
+        }
+        else if ((value) === (ToggleType.Switch)) {
+            return true
+        }
+        else if ((value) === (ToggleType.Button)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ToggleType")
+        }
+    }
+    static isToolbarItem(value: Object | string | number | undefined | boolean, duplicated_value: boolean, duplicated_icon: boolean, duplicated_symbolIcon: boolean, duplicated_action: boolean, duplicated_status: boolean, duplicated_activeIcon: boolean, duplicated_activeSymbolIcon: boolean): boolean {
+        if ((!duplicated_value) && (value?.hasOwnProperty("value"))) {
+            return true
+        }
+        else if ((!duplicated_icon) && (value?.hasOwnProperty("icon"))) {
+            return true
+        }
+        else if ((!duplicated_symbolIcon) && (value?.hasOwnProperty("symbolIcon"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_status) && (value?.hasOwnProperty("status"))) {
+            return true
+        }
+        else if ((!duplicated_activeIcon) && (value?.hasOwnProperty("activeIcon"))) {
+            return true
+        }
+        else if ((!duplicated_activeSymbolIcon) && (value?.hasOwnProperty("activeSymbolIcon"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ToolbarItem")
+        }
+    }
+    static isToolbarItemStatus(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ToolbarItemStatus.NORMAL)) {
+            return true
+        }
+        else if ((value) === (ToolbarItemStatus.DISABLED)) {
+            return true
+        }
+        else if ((value) === (ToolbarItemStatus.ACTIVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ToolbarItemStatus")
+        }
+    }
+    static isTouchEvent(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_touches: boolean, duplicated_changedTouches: boolean, duplicated_stopPropagation: boolean, duplicated_preventDefault: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_touches) && (value?.hasOwnProperty("touches"))) {
+            return true
+        }
+        else if ((!duplicated_changedTouches) && (value?.hasOwnProperty("changedTouches"))) {
+            return true
+        }
+        else if ((!duplicated_stopPropagation) && (value?.hasOwnProperty("stopPropagation"))) {
+            return true
+        }
+        else if ((!duplicated_preventDefault) && (value?.hasOwnProperty("preventDefault"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchEvent")
+        }
+    }
+    static isTouchObject(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_id: boolean, duplicated_displayX: boolean, duplicated_displayY: boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_hand: boolean, duplicated_pressedTime: boolean, duplicated_pressure: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_displayX) && (value?.hasOwnProperty("displayX"))) {
+            return true
+        }
+        else if ((!duplicated_displayY) && (value?.hasOwnProperty("displayY"))) {
+            return true
+        }
+        else if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_hand) && (value?.hasOwnProperty("hand"))) {
+            return true
+        }
+        else if ((!duplicated_pressedTime) && (value?.hasOwnProperty("pressedTime"))) {
+            return true
+        }
+        else if ((!duplicated_pressure) && (value?.hasOwnProperty("pressure"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchObject")
+        }
+    }
+    static isTouchResult(value: Object | string | number | undefined | boolean, duplicated_strategy: boolean, duplicated_id: boolean): boolean {
+        if ((!duplicated_strategy) && (value?.hasOwnProperty("strategy"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchResult")
+        }
+    }
+    static isTouchTestInfo(value: Object | string | number | undefined | boolean, duplicated_windowX: boolean, duplicated_windowY: boolean, duplicated_parentX: boolean, duplicated_parentY: boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_rect: boolean, duplicated_id: boolean): boolean {
+        if ((!duplicated_windowX) && (value?.hasOwnProperty("windowX"))) {
+            return true
+        }
+        else if ((!duplicated_windowY) && (value?.hasOwnProperty("windowY"))) {
+            return true
+        }
+        else if ((!duplicated_parentX) && (value?.hasOwnProperty("parentX"))) {
+            return true
+        }
+        else if ((!duplicated_parentY) && (value?.hasOwnProperty("parentY"))) {
+            return true
+        }
+        else if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_rect) && (value?.hasOwnProperty("rect"))) {
+            return true
+        }
+        else if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchTestInfo")
+        }
+    }
+    static isTouchTestStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TouchTestStrategy.DEFAULT)) {
+            return true
+        }
+        else if ((value) === (TouchTestStrategy.FORWARD_COMPETITION)) {
+            return true
+        }
+        else if ((value) === (TouchTestStrategy.FORWARD)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchTestStrategy")
+        }
+    }
+    static isTouchType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TouchType.Down)) {
+            return true
+        }
+        else if ((value) === (TouchType.Up)) {
+            return true
+        }
+        else if ((value) === (TouchType.Move)) {
+            return true
+        }
+        else if ((value) === (TouchType.Cancel)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TouchType")
+        }
+    }
+    static isTransitionEdge(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TransitionEdge.TOP)) {
+            return true
+        }
+        else if ((value) === (TransitionEdge.BOTTOM)) {
+            return true
+        }
+        else if ((value) === (TransitionEdge.START)) {
+            return true
+        }
+        else if ((value) === (TransitionEdge.END)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TransitionEdge")
+        }
+    }
+    static isTransitionEffect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof TransitionEffect")
+    }
+    static isTransitionHierarchyStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TransitionHierarchyStrategy.NONE)) {
+            return true
+        }
+        else if ((value) === (TransitionHierarchyStrategy.ADAPTIVE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TransitionHierarchyStrategy")
+        }
+    }
+    static isTransitionType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (TransitionType.All)) {
+            return true
+        }
+        else if ((value) === (TransitionType.Insert)) {
+            return true
+        }
+        else if ((value) === (TransitionType.Delete)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TransitionType")
+        }
+    }
+    static isTranslateOptions(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TranslateOptions")
+        }
+    }
+    static isTranslateResult(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof TranslateResult")
+        }
+    }
+    static isUICommonEvent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof UICommonEvent")
+    }
+    static isUIContext(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof UIContext")
+    }
+    static isuiEffect_BrightnessBlender(value: Object | string | number | undefined | boolean, duplicated_cubicRate: boolean, duplicated_quadraticRate: boolean, duplicated_linearRate: boolean, duplicated_degree: boolean, duplicated_saturation: boolean, duplicated_positiveCoefficient: boolean, duplicated_negativeCoefficient: boolean, duplicated_fraction: boolean): boolean {
+        if ((!duplicated_cubicRate) && (value?.hasOwnProperty("cubicRate"))) {
+            return true
+        }
+        else if ((!duplicated_quadraticRate) && (value?.hasOwnProperty("quadraticRate"))) {
+            return true
+        }
+        else if ((!duplicated_linearRate) && (value?.hasOwnProperty("linearRate"))) {
+            return true
+        }
+        else if ((!duplicated_degree) && (value?.hasOwnProperty("degree"))) {
+            return true
+        }
+        else if ((!duplicated_saturation) && (value?.hasOwnProperty("saturation"))) {
+            return true
+        }
+        else if ((!duplicated_positiveCoefficient) && (value?.hasOwnProperty("positiveCoefficient"))) {
+            return true
+        }
+        else if ((!duplicated_negativeCoefficient) && (value?.hasOwnProperty("negativeCoefficient"))) {
+            return true
+        }
+        else if ((!duplicated_fraction) && (value?.hasOwnProperty("fraction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof uiEffect.BrightnessBlender")
+        }
+    }
+    static isuiEffect_BrightnessBlenderParam(value: Object | string | number | undefined | boolean, duplicated_cubicRate: boolean, duplicated_quadraticRate: boolean, duplicated_linearRate: boolean, duplicated_degree: boolean, duplicated_saturation: boolean, duplicated_positiveCoefficient: boolean, duplicated_negativeCoefficient: boolean, duplicated_fraction: boolean): boolean {
+        if ((!duplicated_cubicRate) && (value?.hasOwnProperty("cubicRate"))) {
+            return true
+        }
+        else if ((!duplicated_quadraticRate) && (value?.hasOwnProperty("quadraticRate"))) {
+            return true
+        }
+        else if ((!duplicated_linearRate) && (value?.hasOwnProperty("linearRate"))) {
+            return true
+        }
+        else if ((!duplicated_degree) && (value?.hasOwnProperty("degree"))) {
+            return true
+        }
+        else if ((!duplicated_saturation) && (value?.hasOwnProperty("saturation"))) {
+            return true
+        }
+        else if ((!duplicated_positiveCoefficient) && (value?.hasOwnProperty("positiveCoefficient"))) {
+            return true
+        }
+        else if ((!duplicated_negativeCoefficient) && (value?.hasOwnProperty("negativeCoefficient"))) {
+            return true
+        }
+        else if ((!duplicated_fraction) && (value?.hasOwnProperty("fraction"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof uiEffect.BrightnessBlenderParam")
+        }
+    }
+    static isuiEffect_Filter(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof uiEffect.Filter")
+    }
+    static isuiEffect_VisualEffect(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof uiEffect.VisualEffect")
+    }
+    static isUIExtensionOptions(value: Object | string | number | undefined | boolean, duplicated_isTransferringCaller: boolean, duplicated_placeholder: boolean, duplicated_areaChangePlaceholder: boolean, duplicated_dpiFollowStrategy: boolean, duplicated_windowModeFollowStrategy: boolean): boolean {
+        if ((!duplicated_isTransferringCaller) && (value?.hasOwnProperty("isTransferringCaller"))) {
+            return true
+        }
+        else if ((!duplicated_placeholder) && (value?.hasOwnProperty("placeholder"))) {
+            return true
+        }
+        else if ((!duplicated_areaChangePlaceholder) && (value?.hasOwnProperty("areaChangePlaceholder"))) {
+            return true
+        }
+        else if ((!duplicated_dpiFollowStrategy) && (value?.hasOwnProperty("dpiFollowStrategy"))) {
+            return true
+        }
+        else if ((!duplicated_windowModeFollowStrategy) && (value?.hasOwnProperty("windowModeFollowStrategy"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof UIExtensionOptions")
+        }
+    }
+    static isUIExtensionProxy(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof UIExtensionProxy")
+    }
+    static isUIGestureEvent(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof UIGestureEvent")
+    }
+    static isUnderlineColor(value: Object | string | number | undefined | boolean, duplicated_typing: boolean, duplicated_normal: boolean, duplicated_error: boolean, duplicated_disable: boolean): boolean {
+        if ((!duplicated_typing) && (value?.hasOwnProperty("typing"))) {
+            return true
+        }
+        else if ((!duplicated_normal) && (value?.hasOwnProperty("normal"))) {
+            return true
+        }
+        else if ((!duplicated_error) && (value?.hasOwnProperty("error"))) {
+            return true
+        }
+        else if ((!duplicated_disable) && (value?.hasOwnProperty("disable"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof UnderlineColor")
+        }
+    }
+    static isunifiedDataChannel_Summary(value: Object | string | number | undefined | boolean, duplicated_summary: boolean, duplicated_totalSize: boolean): boolean {
+        if ((!duplicated_summary) && (value?.hasOwnProperty("summary"))) {
+            return true
+        }
+        else if ((!duplicated_totalSize) && (value?.hasOwnProperty("totalSize"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof unifiedDataChannel.Summary")
+        }
+    }
+    static isunifiedDataChannel_UnifiedData(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof unifiedDataChannel.UnifiedData")
+    }
+    static isuniformTypeDescriptor_UniformDataType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (uniformTypeDescriptor.UniformDataType.ENTITY)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OBJECT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.COMPOSITE_OBJECT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PLAIN_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.HTML)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.HYPERLINK)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.XML)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.XHTML)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.RSS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SMIL)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SOURCE_CODE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SHELL_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.CSH_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PERL_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PHP_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PYTHON_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.RUBY_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TYPE_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.JAVA_SCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.CSS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.C_HEADER)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.C_SOURCE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.C_PLUS_PLUS_HEADER)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.C_PLUS_PLUS_SOURCE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.JAVA_SOURCE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TEX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MARKDOWN)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ASC_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.RICH_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DELIMITED_VALUES_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.COMMA_SEPARATED_VALUES_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TAB_SEPARATED_VALUES_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EBOOK)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EPUB)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AZW)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AZW3)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.KFX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MOBI)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MEDIA)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.JPEG)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PNG)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.RAW_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TIFF)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.BMP)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ICO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PHOTOSHOP_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AI_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FAX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.JFX_FAX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EFX_FAX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.XBITMAP_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.GIF)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TGA_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SGI_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENEXR_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FLASHPIX_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WORD_DOC)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EXCEL)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WORD_DOT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POWERPOINT_PPS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POWERPOINT_POT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EXCEL_XLT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VISIO_VSD)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PDF)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POSTSCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ENCAPSULATED_POSTSCRIPT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VIDEO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AVI)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEG)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEG4)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VIDEO_3GPP)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VIDEO_3GPP2)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEGURL_VIDEO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WM)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WMV)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WMP)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WVX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WMX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.REALMEDIA)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MATROSKA_VIDEO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FLASH)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AAC)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AIFF)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ALAC)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FLAC)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MP3)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OGG)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PCM)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WMA)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WAVEFORM_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WINDOWS_MEDIA_WAX)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AU_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.AIFC_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEGURL_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEG_4_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MP2)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MPEG_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ULAW_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SD2_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.REALAUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MATROSKA_AUDIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FILE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DIRECTORY)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FOLDER)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SYMLINK)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.BZ2_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPG)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TAZ_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WEB_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DISK_IMAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ISO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TAR_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ZIP_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.JAVA_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.GNU_TAR_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.GNU_ZIP_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.GNU_ZIP_TAR_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENXML)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WORDPROCESSINGML_DOCUMENT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SPREADSHEETML_SHEET)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PRESENTATIONML_PRESENTATION)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DRAWINGML_VISIO)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DRAWINGML_TEMPLATE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.WORDPROCESSINGML_TEMPLATE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PRESENTATIONML_TEMPLATE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PRESENTATIONML_SLIDESHOW)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SPREADSHEETML_TEMPLATE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT_TEXT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT_SPREADSHEET)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT_PRESENTATION)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT_GRAPHICS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENDOCUMENT_FORMULA)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.STUFFIT_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.RAR_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SEVEN_ZIP_ARCHIVE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.CALENDAR)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VCS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.ICS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.CONTACT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.DATABASE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.MESSAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.EXECUTABLE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.PORTABLE_EXECUTABLE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.SUN_JAVA_CLASS)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.VCARD)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.NAVIGATION)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.LOCATION)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TRUETYPE_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.TRUETYPE_COLLECTION_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENTYPE_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POSTSCRIPT_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POSTSCRIPT_PFB_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.POSTSCRIPT_PFA_FONT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_FORM)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_APP_ITEM)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_PIXEL_MAP)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_ATOMIC_SERVICE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_PACKAGE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_HAP)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_HDOC)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_HINOTE)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_STYLED_STRING)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OPENHARMONY_WANT)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OFD)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.CAD)) {
+            return true
+        }
+        else if ((value) === (uniformTypeDescriptor.UniformDataType.OCTET_STREAM)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof uniformTypeDescriptor.UniformDataType")
+        }
+    }
+    static isUrlStyle(value: Object | string | number | undefined | boolean, duplicated_url: boolean): boolean {
+        if ((!duplicated_url) && (value?.hasOwnProperty("url"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof UrlStyle")
+        }
+    }
+    static isUserDataSpan(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof UserDataSpan")
+    }
+    static isVector2(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Vector2")
+        }
+    }
+    static isVector3(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_z: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_z) && (value?.hasOwnProperty("z"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Vector3")
+        }
+    }
+    static isVerticalAlign(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (VerticalAlign.Top)) {
+            return true
+        }
+        else if ((value) === (VerticalAlign.Center)) {
+            return true
+        }
+        else if ((value) === (VerticalAlign.Bottom)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof VerticalAlign")
+        }
+    }
+    static isVideoController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof VideoController")
+    }
+    static isVideoOptions(value: Object | string | number | undefined | boolean, duplicated_src: boolean, duplicated_currentProgressRate: boolean, duplicated_previewUri: boolean, duplicated_controller: boolean, duplicated_imageAIOptions: boolean, duplicated_posterOptions: boolean): boolean {
+        if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_currentProgressRate) && (value?.hasOwnProperty("currentProgressRate"))) {
+            return true
+        }
+        else if ((!duplicated_previewUri) && (value?.hasOwnProperty("previewUri"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else if ((!duplicated_imageAIOptions) && (value?.hasOwnProperty("imageAIOptions"))) {
+            return true
+        }
+        else if ((!duplicated_posterOptions) && (value?.hasOwnProperty("posterOptions"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof VideoOptions")
+        }
+    }
+    static isViewportFit(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (ViewportFit.AUTO)) {
+            return true
+        }
+        else if ((value) === (ViewportFit.CONTAINS)) {
+            return true
+        }
+        else if ((value) === (ViewportFit.COVER)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ViewportFit")
+        }
+    }
+    static isViewportRect(value: Object | string | number | undefined | boolean, duplicated_x: boolean, duplicated_y: boolean, duplicated_width: boolean, duplicated_height: boolean): boolean {
+        if ((!duplicated_x) && (value?.hasOwnProperty("x"))) {
+            return true
+        }
+        else if ((!duplicated_y) && (value?.hasOwnProperty("y"))) {
+            return true
+        }
+        else if ((!duplicated_width) && (value?.hasOwnProperty("width"))) {
+            return true
+        }
+        else if ((!duplicated_height) && (value?.hasOwnProperty("height"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof ViewportRect")
+        }
+    }
+    static isVisibility(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Visibility.Visible)) {
+            return true
+        }
+        else if ((value) === (Visibility.Hidden)) {
+            return true
+        }
+        else if ((value) === (Visibility.None)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Visibility")
+        }
+    }
+    static isVisibleAreaEventOptions(value: Object | string | number | undefined | boolean, duplicated_ratios: boolean, duplicated_expectedUpdateInterval: boolean): boolean {
+        if ((!duplicated_ratios) && (value?.hasOwnProperty("ratios"))) {
+            return true
+        }
+        else if ((!duplicated_expectedUpdateInterval) && (value?.hasOwnProperty("expectedUpdateInterval"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof VisibleAreaEventOptions")
+        }
+    }
+    static isVisibleListContentInfo(value: Object | string | number | undefined | boolean, duplicated_index: boolean, duplicated_itemGroupArea: boolean, duplicated_itemIndexInGroup: boolean): boolean {
+        if ((!duplicated_index) && (value?.hasOwnProperty("index"))) {
+            return true
+        }
+        else if ((!duplicated_itemGroupArea) && (value?.hasOwnProperty("itemGroupArea"))) {
+            return true
+        }
+        else if ((!duplicated_itemIndexInGroup) && (value?.hasOwnProperty("itemIndexInGroup"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof VisibleListContentInfo")
+        }
+    }
+    static isWant(value: Object | string | number | undefined | boolean, duplicated_bundleName: boolean, duplicated_abilityName: boolean, duplicated_deviceId: boolean, duplicated_uri: boolean, duplicated_type: boolean, duplicated_flags: boolean, duplicated_action: boolean, duplicated_parameters: boolean, duplicated_entities: boolean, duplicated_moduleName: boolean): boolean {
+        if ((!duplicated_bundleName) && (value?.hasOwnProperty("bundleName"))) {
+            return true
+        }
+        else if ((!duplicated_abilityName) && (value?.hasOwnProperty("abilityName"))) {
+            return true
+        }
+        else if ((!duplicated_deviceId) && (value?.hasOwnProperty("deviceId"))) {
+            return true
+        }
+        else if ((!duplicated_uri) && (value?.hasOwnProperty("uri"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_flags) && (value?.hasOwnProperty("flags"))) {
+            return true
+        }
+        else if ((!duplicated_action) && (value?.hasOwnProperty("action"))) {
+            return true
+        }
+        else if ((!duplicated_parameters) && (value?.hasOwnProperty("parameters"))) {
+            return true
+        }
+        else if ((!duplicated_entities) && (value?.hasOwnProperty("entities"))) {
+            return true
+        }
+        else if ((!duplicated_moduleName) && (value?.hasOwnProperty("moduleName"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Want")
+        }
+    }
+    static isWaterFlowLayoutMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WaterFlowLayoutMode.ALWAYS_TOP_DOWN)) {
+            return true
+        }
+        else if ((value) === (WaterFlowLayoutMode.SLIDING_WINDOW)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WaterFlowLayoutMode")
+        }
+    }
+    static isWaterFlowOptions(value: Object | string | number | undefined | boolean, duplicated_footer: boolean, duplicated_footerContent: boolean, duplicated_scroller: boolean, duplicated_sections: boolean, duplicated_layoutMode: boolean): boolean {
+        if ((!duplicated_footer) && (value?.hasOwnProperty("footer"))) {
+            return true
+        }
+        else if ((!duplicated_footerContent) && (value?.hasOwnProperty("footerContent"))) {
+            return true
+        }
+        else if ((!duplicated_scroller) && (value?.hasOwnProperty("scroller"))) {
+            return true
+        }
+        else if ((!duplicated_sections) && (value?.hasOwnProperty("sections"))) {
+            return true
+        }
+        else if ((!duplicated_layoutMode) && (value?.hasOwnProperty("layoutMode"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WaterFlowOptions")
+        }
+    }
+    static isWaterFlowSections(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WaterFlowSections")
+    }
+    static isWebCaptureMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebCaptureMode.HOME_SCREEN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebCaptureMode")
+        }
+    }
+    static isWebContextMenuParam(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebContextMenuParam")
+    }
+    static isWebContextMenuResult(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebContextMenuResult")
+    }
+    static isWebCookie(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebCookie")
+    }
+    static isWebDarkMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebDarkMode.Off)) {
+            return true
+        }
+        else if ((value) === (WebDarkMode.On)) {
+            return true
+        }
+        else if ((value) === (WebDarkMode.Auto)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebDarkMode")
+        }
+    }
+    static isWebElementType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebElementType.IMAGE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebElementType")
+        }
+    }
+    static isWebKeyboardAvoidMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebKeyboardAvoidMode.RESIZE_VISUAL)) {
+            return true
+        }
+        else if ((value) === (WebKeyboardAvoidMode.RESIZE_CONTENT)) {
+            return true
+        }
+        else if ((value) === (WebKeyboardAvoidMode.OVERLAYS_CONTENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebKeyboardAvoidMode")
+        }
+    }
+    static isWebKeyboardCallbackInfo(value: Object | string | number | undefined | boolean, duplicated_controller: boolean, duplicated_attributes: boolean): boolean {
+        if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else if ((!duplicated_attributes) && (value?.hasOwnProperty("attributes"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebKeyboardCallbackInfo")
+        }
+    }
+    static isWebKeyboardController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebKeyboardController")
+    }
+    static isWebKeyboardOptions(value: Object | string | number | undefined | boolean, duplicated_useSystemKeyboard: boolean, duplicated_enterKeyType: boolean, duplicated_customKeyboard: boolean): boolean {
+        if ((!duplicated_useSystemKeyboard) && (value?.hasOwnProperty("useSystemKeyboard"))) {
+            return true
+        }
+        else if ((!duplicated_enterKeyType) && (value?.hasOwnProperty("enterKeyType"))) {
+            return true
+        }
+        else if ((!duplicated_customKeyboard) && (value?.hasOwnProperty("customKeyboard"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebKeyboardOptions")
+        }
+    }
+    static isWebLayoutMode(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebLayoutMode.NONE)) {
+            return true
+        }
+        else if ((value) === (WebLayoutMode.FIT_CONTENT)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebLayoutMode")
+        }
+    }
+    static isWebMediaOptions(value: Object | string | number | undefined | boolean, duplicated_resumeInterval: boolean, duplicated_audioExclusive: boolean): boolean {
+        if ((!duplicated_resumeInterval) && (value?.hasOwnProperty("resumeInterval"))) {
+            return true
+        }
+        else if ((!duplicated_audioExclusive) && (value?.hasOwnProperty("audioExclusive"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebMediaOptions")
+        }
+    }
+    static isWebNavigationType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebNavigationType.UNKNOWN)) {
+            return true
+        }
+        else if ((value) === (WebNavigationType.MAIN_FRAME_NEW_ENTRY)) {
+            return true
+        }
+        else if ((value) === (WebNavigationType.MAIN_FRAME_EXISTING_ENTRY)) {
+            return true
+        }
+        else if ((value) === (WebNavigationType.NAVIGATION_TYPE_NEW_SUBFRAME)) {
+            return true
+        }
+        else if ((value) === (WebNavigationType.NAVIGATION_TYPE_AUTO_SUBFRAME)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebNavigationType")
+        }
+    }
+    static isWebOptions(value: Object | string | number | undefined | boolean, duplicated_src: boolean, duplicated_controller: boolean, duplicated_renderMode: boolean, duplicated_incognitoMode: boolean, duplicated_sharedRenderProcessToken: boolean): boolean {
+        if ((!duplicated_src) && (value?.hasOwnProperty("src"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else if ((!duplicated_renderMode) && (value?.hasOwnProperty("renderMode"))) {
+            return true
+        }
+        else if ((!duplicated_incognitoMode) && (value?.hasOwnProperty("incognitoMode"))) {
+            return true
+        }
+        else if ((!duplicated_sharedRenderProcessToken) && (value?.hasOwnProperty("sharedRenderProcessToken"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebOptions")
+        }
+    }
+    static isWebResourceError(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebResourceError")
+    }
+    static isWebResourceRequest(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebResourceRequest")
+    }
+    static isWebResourceResponse(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WebResourceResponse")
+    }
+    static isWebResponseType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WebResponseType.LONG_PRESS)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WebResponseType")
+        }
+    }
+    static iswebview_WebHeader(value: Object | string | number | undefined | boolean, duplicated_headerKey: boolean, duplicated_headerValue: boolean): boolean {
+        if ((!duplicated_headerKey) && (value?.hasOwnProperty("headerKey"))) {
+            return true
+        }
+        else if ((!duplicated_headerValue) && (value?.hasOwnProperty("headerValue"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof webview.WebHeader")
+        }
+    }
+    static iswebview_WebviewController(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof webview.WebviewController")
+    }
+    static isWeek(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (Week.Mon)) {
+            return true
+        }
+        else if ((value) === (Week.Tue)) {
+            return true
+        }
+        else if ((value) === (Week.Wed)) {
+            return true
+        }
+        else if ((value) === (Week.Thur)) {
+            return true
+        }
+        else if ((value) === (Week.Fri)) {
+            return true
+        }
+        else if ((value) === (Week.Sat)) {
+            return true
+        }
+        else if ((value) === (Week.Sun)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof Week")
+        }
+    }
+    static isWeekStyle(value: Object | string | number | undefined | boolean, duplicated_weekColor: boolean, duplicated_weekendDayColor: boolean, duplicated_weekendLunarColor: boolean, duplicated_weekFontSize: boolean, duplicated_weekHeight: boolean, duplicated_weekWidth: boolean, duplicated_weekAndDayRowSpace: boolean): boolean {
+        if ((!duplicated_weekColor) && (value?.hasOwnProperty("weekColor"))) {
+            return true
+        }
+        else if ((!duplicated_weekendDayColor) && (value?.hasOwnProperty("weekendDayColor"))) {
+            return true
+        }
+        else if ((!duplicated_weekendLunarColor) && (value?.hasOwnProperty("weekendLunarColor"))) {
+            return true
+        }
+        else if ((!duplicated_weekFontSize) && (value?.hasOwnProperty("weekFontSize"))) {
+            return true
+        }
+        else if ((!duplicated_weekHeight) && (value?.hasOwnProperty("weekHeight"))) {
+            return true
+        }
+        else if ((!duplicated_weekWidth) && (value?.hasOwnProperty("weekWidth"))) {
+            return true
+        }
+        else if ((!duplicated_weekAndDayRowSpace) && (value?.hasOwnProperty("weekAndDayRowSpace"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WeekStyle")
+        }
+    }
+    static isWidthBreakpoint(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WidthBreakpoint.WIDTH_XS)) {
+            return true
+        }
+        else if ((value) === (WidthBreakpoint.WIDTH_SM)) {
+            return true
+        }
+        else if ((value) === (WidthBreakpoint.WIDTH_MD)) {
+            return true
+        }
+        else if ((value) === (WidthBreakpoint.WIDTH_LG)) {
+            return true
+        }
+        else if ((value) === (WidthBreakpoint.WIDTH_XL)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WidthBreakpoint")
+        }
+    }
+    static iswindow_SystemBarStyle(value: Object | string | number | undefined | boolean, duplicated_statusBarContentColor: boolean): boolean {
+        if ((!duplicated_statusBarContentColor) && (value?.hasOwnProperty("statusBarContentColor"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof window.SystemBarStyle")
+        }
+    }
+    static iswindow_WindowStatusType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (window.WindowStatusType.UNDEFINED)) {
+            return true
+        }
+        else if ((value) === (window.WindowStatusType.FULL_SCREEN)) {
+            return true
+        }
+        else if ((value) === (window.WindowStatusType.MAXIMIZE)) {
+            return true
+        }
+        else if ((value) === (window.WindowStatusType.MINIMIZE)) {
+            return true
+        }
+        else if ((value) === (window.WindowStatusType.FLOATING)) {
+            return true
+        }
+        else if ((value) === (window.WindowStatusType.SPLIT_SCREEN)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof window.WindowStatusType")
+        }
+    }
+    static isWindowAnimationTarget(value: Object | string | number | undefined | boolean, duplicated_bundleName: boolean, duplicated_abilityName: boolean, duplicated_windowBounds: boolean, duplicated_missionId: boolean): boolean {
+        if ((!duplicated_bundleName) && (value?.hasOwnProperty("bundleName"))) {
+            return true
+        }
+        else if ((!duplicated_abilityName) && (value?.hasOwnProperty("abilityName"))) {
+            return true
+        }
+        else if ((!duplicated_windowBounds) && (value?.hasOwnProperty("windowBounds"))) {
+            return true
+        }
+        else if ((!duplicated_missionId) && (value?.hasOwnProperty("missionId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WindowAnimationTarget")
+        }
+    }
+    static isWindowModeFollowStrategy(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WindowModeFollowStrategy.FOLLOW_HOST_WINDOW_MODE)) {
+            return true
+        }
+        else if ((value) === (WindowModeFollowStrategy.FOLLOW_UI_EXTENSION_ABILITY_WINDOW_MODE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WindowModeFollowStrategy")
+        }
+    }
+    static isWordBreak(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (WordBreak.NORMAL)) {
+            return true
+        }
+        else if ((value) === (WordBreak.BREAK_ALL)) {
+            return true
+        }
+        else if ((value) === (WordBreak.BREAK_WORD)) {
+            return true
+        }
+        else if ((value) === (WordBreak.HYPHENATION)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WordBreak")
+        }
+    }
+    static isWorkerEventListener(value: Object | string | number | undefined | boolean): boolean {
+        throw new Error("Can not discriminate value typeof WorkerEventListener")
+    }
+    static isWorkerOptions(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_name: boolean, duplicated_shared: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_name) && (value?.hasOwnProperty("name"))) {
+            return true
+        }
+        else if ((!duplicated_shared) && (value?.hasOwnProperty("shared"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WorkerOptions")
+        }
+    }
+    static isWorkStateStyle(value: Object | string | number | undefined | boolean, duplicated_workDayMarkColor: boolean, duplicated_offDayMarkColor: boolean, duplicated_workDayMarkSize: boolean, duplicated_offDayMarkSize: boolean, duplicated_workStateWidth: boolean, duplicated_workStateHorizontalMovingDistance: boolean, duplicated_workStateVerticalMovingDistance: boolean): boolean {
+        if ((!duplicated_workDayMarkColor) && (value?.hasOwnProperty("workDayMarkColor"))) {
+            return true
+        }
+        else if ((!duplicated_offDayMarkColor) && (value?.hasOwnProperty("offDayMarkColor"))) {
+            return true
+        }
+        else if ((!duplicated_workDayMarkSize) && (value?.hasOwnProperty("workDayMarkSize"))) {
+            return true
+        }
+        else if ((!duplicated_offDayMarkSize) && (value?.hasOwnProperty("offDayMarkSize"))) {
+            return true
+        }
+        else if ((!duplicated_workStateWidth) && (value?.hasOwnProperty("workStateWidth"))) {
+            return true
+        }
+        else if ((!duplicated_workStateHorizontalMovingDistance) && (value?.hasOwnProperty("workStateHorizontalMovingDistance"))) {
+            return true
+        }
+        else if ((!duplicated_workStateVerticalMovingDistance) && (value?.hasOwnProperty("workStateVerticalMovingDistance"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof WorkStateStyle")
+        }
+    }
+    static isXComponentController(value: Object | string | number | undefined | boolean, duplicated_onSurfaceCreated: boolean, duplicated_onSurfaceChanged: boolean, duplicated_onSurfaceDestroyed: boolean): boolean {
+        if ((!duplicated_onSurfaceCreated) && (value?.hasOwnProperty("onSurfaceCreated"))) {
+            return true
+        }
+        else if ((!duplicated_onSurfaceChanged) && (value?.hasOwnProperty("onSurfaceChanged"))) {
+            return true
+        }
+        else if ((!duplicated_onSurfaceDestroyed) && (value?.hasOwnProperty("onSurfaceDestroyed"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof XComponentController")
+        }
+    }
+    static isXComponentOptions(value: Object | string | number | undefined | boolean, duplicated_type: boolean, duplicated_controller: boolean, duplicated_imageAIOptions: boolean, duplicated_screenId: boolean): boolean {
+        if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else if ((!duplicated_imageAIOptions) && (value?.hasOwnProperty("imageAIOptions"))) {
+            return true
+        }
+        else if ((!duplicated_screenId) && (value?.hasOwnProperty("screenId"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof XComponentOptions")
+        }
+    }
+    static isXComponentParameter(value: Object | string | number | undefined | boolean, duplicated_id: boolean, duplicated_type: boolean, duplicated_libraryname: boolean, duplicated_controller: boolean): boolean {
+        if ((!duplicated_id) && (value?.hasOwnProperty("id"))) {
+            return true
+        }
+        else if ((!duplicated_type) && (value?.hasOwnProperty("type"))) {
+            return true
+        }
+        else if ((!duplicated_libraryname) && (value?.hasOwnProperty("libraryname"))) {
+            return true
+        }
+        else if ((!duplicated_controller) && (value?.hasOwnProperty("controller"))) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof XComponentParameter")
+        }
+    }
+    static isXComponentType(value: Object | string | number | undefined | boolean): boolean {
+        if ((value) === (XComponentType.SURFACE)) {
+            return true
+        }
+        else if ((value) === (XComponentType.TEXTURE)) {
+            return true
+        }
+        else {
+            throw new Error("Can not discriminate value typeof XComponentType")
+        }
+    }
+    static AccessibilityHoverType_ToNumeric(value: AccessibilityHoverType): int32 {
+        return value as int32
+    }
+    static AccessibilityHoverType_FromNumeric(ordinal: int32): AccessibilityHoverType {
+        return ordinal as AccessibilityHoverType
+    }
+    static AccessibilityRoleType_ToNumeric(value: AccessibilityRoleType): int32 {
+        return value as int32
+    }
+    static AccessibilityRoleType_FromNumeric(ordinal: int32): AccessibilityRoleType {
+        return ordinal as AccessibilityRoleType
+    }
+    static AccessibilitySamePageMode_ToNumeric(value: AccessibilitySamePageMode): int32 {
+        return value as int32
+    }
+    static AccessibilitySamePageMode_FromNumeric(ordinal: int32): AccessibilitySamePageMode {
+        return ordinal as AccessibilitySamePageMode
+    }
+    static AdaptiveColor_ToNumeric(value: AdaptiveColor): int32 {
+        return value as int32
+    }
+    static AdaptiveColor_FromNumeric(ordinal: int32): AdaptiveColor {
+        return ordinal as AdaptiveColor
+    }
+    static Alignment_ToNumeric(value: Alignment): int32 {
+        return value as int32
+    }
+    static Alignment_FromNumeric(ordinal: int32): Alignment {
+        return ordinal as Alignment
+    }
+    static AnimationMode_ToNumeric(value: AnimationMode): int32 {
+        return value as int32
+    }
+    static AnimationMode_FromNumeric(ordinal: int32): AnimationMode {
+        return ordinal as AnimationMode
+    }
+    static AnimationStatus_ToNumeric(value: AnimationStatus): int32 {
+        return value as int32
+    }
+    static AnimationStatus_FromNumeric(ordinal: int32): AnimationStatus {
+        return ordinal as AnimationStatus
+    }
+    static AppRotation_ToNumeric(value: AppRotation): int32 {
+        return value as int32
+    }
+    static AppRotation_FromNumeric(ordinal: int32): AppRotation {
+        return ordinal as AppRotation
+    }
+    static ArrowPointPosition_ToNumeric(value: ArrowPointPosition): int32 {
+        return value as int32
+    }
+    static ArrowPointPosition_FromNumeric(ordinal: int32): ArrowPointPosition {
+        return ordinal as ArrowPointPosition
+    }
+    static ArrowPosition_ToNumeric(value: ArrowPosition): int32 {
+        return value as int32
+    }
+    static ArrowPosition_FromNumeric(ordinal: int32): ArrowPosition {
+        return ordinal as ArrowPosition
+    }
+    static AutoCapitalizationMode_ToNumeric(value: AutoCapitalizationMode): int32 {
+        return value as int32
+    }
+    static AutoCapitalizationMode_FromNumeric(ordinal: int32): AutoCapitalizationMode {
+        return ordinal as AutoCapitalizationMode
+    }
+    static AvoidanceMode_ToNumeric(value: AvoidanceMode): int32 {
+        return value as int32
+    }
+    static AvoidanceMode_FromNumeric(ordinal: int32): AvoidanceMode {
+        return ordinal as AvoidanceMode
+    }
+    static Axis_ToNumeric(value: Axis): int32 {
+        return value as int32
+    }
+    static Axis_FromNumeric(ordinal: int32): Axis {
+        return ordinal as Axis
+    }
+    static AxisAction_ToNumeric(value: AxisAction): int32 {
+        return value as int32
+    }
+    static AxisAction_FromNumeric(ordinal: int32): AxisAction {
+        return ordinal as AxisAction
+    }
+    static AxisModel_ToNumeric(value: AxisModel): int32 {
+        return value as int32
+    }
+    static AxisModel_FromNumeric(ordinal: int32): AxisModel {
+        return ordinal as AxisModel
+    }
+    static BadgePosition_ToNumeric(value: BadgePosition): int32 {
+        return value as int32
+    }
+    static BadgePosition_FromNumeric(ordinal: int32): BadgePosition {
+        return ordinal as BadgePosition
+    }
+    static BarMode_ToNumeric(value: BarMode): int32 {
+        return value as int32
+    }
+    static BarMode_FromNumeric(ordinal: int32): BarMode {
+        return ordinal as BarMode
+    }
+    static BarPosition_ToNumeric(value: BarPosition): int32 {
+        return value as int32
+    }
+    static BarPosition_FromNumeric(ordinal: int32): BarPosition {
+        return ordinal as BarPosition
+    }
+    static BarrierDirection_ToNumeric(value: BarrierDirection): int32 {
+        return value as int32
+    }
+    static BarrierDirection_FromNumeric(ordinal: int32): BarrierDirection {
+        return ordinal as BarrierDirection
+    }
+    static BarState_ToNumeric(value: BarState): int32 {
+        return value as int32
+    }
+    static BarState_FromNumeric(ordinal: int32): BarState {
+        return ordinal as BarState
+    }
+    static BarStyle_ToNumeric(value: BarStyle): int32 {
+        return value as int32
+    }
+    static BarStyle_FromNumeric(ordinal: int32): BarStyle {
+        return ordinal as BarStyle
+    }
+    static BlendApplyType_ToNumeric(value: BlendApplyType): int32 {
+        return value as int32
+    }
+    static BlendApplyType_FromNumeric(ordinal: int32): BlendApplyType {
+        return ordinal as BlendApplyType
+    }
+    static BlendMode_ToNumeric(value: BlendMode): int32 {
+        return value as int32
+    }
+    static BlendMode_FromNumeric(ordinal: int32): BlendMode {
+        return ordinal as BlendMode
+    }
+    static BlurOnKeyboardHideMode_ToNumeric(value: BlurOnKeyboardHideMode): int32 {
+        return value as int32
+    }
+    static BlurOnKeyboardHideMode_FromNumeric(ordinal: int32): BlurOnKeyboardHideMode {
+        return ordinal as BlurOnKeyboardHideMode
+    }
+    static BlurStyle_ToNumeric(value: BlurStyle): int32 {
+        return value as int32
+    }
+    static BlurStyle_FromNumeric(ordinal: int32): BlurStyle {
+        return ordinal as BlurStyle
+    }
+    static BlurStyleActivePolicy_ToNumeric(value: BlurStyleActivePolicy): int32 {
+        return value as int32
+    }
+    static BlurStyleActivePolicy_FromNumeric(ordinal: int32): BlurStyleActivePolicy {
+        return ordinal as BlurStyleActivePolicy
+    }
+    static BorderStyle_ToNumeric(value: BorderStyle): int32 {
+        return value as int32
+    }
+    static BorderStyle_FromNumeric(ordinal: int32): BorderStyle {
+        return ordinal as BorderStyle
+    }
+    static BreakpointsReference_ToNumeric(value: BreakpointsReference): int32 {
+        return value as int32
+    }
+    static BreakpointsReference_FromNumeric(ordinal: int32): BreakpointsReference {
+        return ordinal as BreakpointsReference
+    }
+    static ButtonRole_ToNumeric(value: ButtonRole): int32 {
+        return value as int32
+    }
+    static ButtonRole_FromNumeric(ordinal: int32): ButtonRole {
+        return ordinal as ButtonRole
+    }
+    static ButtonStyleMode_ToNumeric(value: ButtonStyleMode): int32 {
+        return value as int32
+    }
+    static ButtonStyleMode_FromNumeric(ordinal: int32): ButtonStyleMode {
+        return ordinal as ButtonStyleMode
+    }
+    static ButtonType_ToNumeric(value: ButtonType): int32 {
+        return value as int32
+    }
+    static ButtonType_FromNumeric(ordinal: int32): ButtonType {
+        return ordinal as ButtonType
+    }
+    static CacheMode_ToNumeric(value: CacheMode): int32 {
+        return value as int32
+    }
+    static CacheMode_FromNumeric(ordinal: int32): CacheMode {
+        return ordinal as CacheMode
+    }
+    static CalendarAlign_ToNumeric(value: CalendarAlign): int32 {
+        return value as int32
+    }
+    static CalendarAlign_FromNumeric(ordinal: int32): CalendarAlign {
+        return ordinal as CalendarAlign
+    }
+    static CancelButtonStyle_ToNumeric(value: CancelButtonStyle): int32 {
+        return value as int32
+    }
+    static CancelButtonStyle_FromNumeric(ordinal: int32): CancelButtonStyle {
+        return ordinal as CancelButtonStyle
+    }
+    static ChainEdgeEffect_ToNumeric(value: ChainEdgeEffect): int32 {
+        return value as int32
+    }
+    static ChainEdgeEffect_FromNumeric(ordinal: int32): ChainEdgeEffect {
+        return ordinal as ChainEdgeEffect
+    }
+    static ChainStyle_ToNumeric(value: ChainStyle): int32 {
+        return value as int32
+    }
+    static ChainStyle_FromNumeric(ordinal: int32): ChainStyle {
+        return ordinal as ChainStyle
+    }
+    static CheckBoxShape_ToNumeric(value: CheckBoxShape): int32 {
+        return value as int32
+    }
+    static CheckBoxShape_FromNumeric(ordinal: int32): CheckBoxShape {
+        return ordinal as CheckBoxShape
+    }
+    static ClickEffectLevel_ToNumeric(value: ClickEffectLevel): int32 {
+        return value as int32
+    }
+    static ClickEffectLevel_FromNumeric(ordinal: int32): ClickEffectLevel {
+        return ordinal as ClickEffectLevel
+    }
+    static Color_ToNumeric(value: Color): int32 {
+        return value as int32
+    }
+    static Color_FromNumeric(ordinal: int32): Color {
+        return ordinal as Color
+    }
+    static ColoringStrategy_ToNumeric(value: ColoringStrategy): int32 {
+        return value as int32
+    }
+    static ColoringStrategy_FromNumeric(ordinal: int32): ColoringStrategy {
+        return ordinal as ColoringStrategy
+    }
+    static ColorMode_ToNumeric(value: ColorMode): int32 {
+        return value as int32
+    }
+    static ColorMode_FromNumeric(ordinal: int32): ColorMode {
+        return ordinal as ColorMode
+    }
+    static ContentClipMode_ToNumeric(value: ContentClipMode): int32 {
+        return value as int32
+    }
+    static ContentClipMode_FromNumeric(ordinal: int32): ContentClipMode {
+        return ordinal as ContentClipMode
+    }
+    static ContentType_ToNumeric(value: ContentType): int32 {
+        return value as int32
+    }
+    static ContentType_FromNumeric(ordinal: int32): ContentType {
+        return ordinal as ContentType
+    }
+    static ContextMenuEditStateFlags_ToNumeric(value: ContextMenuEditStateFlags): int32 {
+        return value as int32
+    }
+    static ContextMenuEditStateFlags_FromNumeric(ordinal: int32): ContextMenuEditStateFlags {
+        return ordinal as ContextMenuEditStateFlags
+    }
+    static ContextMenuInputFieldType_ToNumeric(value: ContextMenuInputFieldType): int32 {
+        return value as int32
+    }
+    static ContextMenuInputFieldType_FromNumeric(ordinal: int32): ContextMenuInputFieldType {
+        return ordinal as ContextMenuInputFieldType
+    }
+    static ContextMenuMediaType_ToNumeric(value: ContextMenuMediaType): int32 {
+        return value as int32
+    }
+    static ContextMenuMediaType_FromNumeric(ordinal: int32): ContextMenuMediaType {
+        return ordinal as ContextMenuMediaType
+    }
+    static ContextMenuSourceType_ToNumeric(value: ContextMenuSourceType): int32 {
+        return value as int32
+    }
+    static ContextMenuSourceType_FromNumeric(ordinal: int32): ContextMenuSourceType {
+        return ordinal as ContextMenuSourceType
+    }
+    static ControlSize_ToNumeric(value: ControlSize): int32 {
+        return value as int32
+    }
+    static ControlSize_FromNumeric(ordinal: int32): ControlSize {
+        return ordinal as ControlSize
+    }
+    static CopyOptions_ToNumeric(value: CopyOptions): int32 {
+        return value as int32
+    }
+    static CopyOptions_FromNumeric(ordinal: int32): CopyOptions {
+        return ordinal as CopyOptions
+    }
+    static CrownAction_ToNumeric(value: CrownAction): int32 {
+        return value as int32
+    }
+    static CrownAction_FromNumeric(ordinal: int32): CrownAction {
+        return ordinal as CrownAction
+    }
+    static CrownSensitivity_ToNumeric(value: CrownSensitivity): int32 {
+        return value as int32
+    }
+    static CrownSensitivity_FromNumeric(ordinal: int32): CrownSensitivity {
+        return ordinal as CrownSensitivity
+    }
+    static curves_Curve_ToNumeric(value: curves.Curve): int32 {
+        return value as int32
+    }
+    static curves_Curve_FromNumeric(ordinal: int32): curves.Curve {
+        return ordinal as curves.Curve
+    }
+    static DataOperationType_ToNumeric(value: DataOperationType): int32 {
+        return value as int32
+    }
+    static DataOperationType_FromNumeric(ordinal: int32): DataOperationType {
+        return ordinal as DataOperationType
+    }
+    static DataPanelType_ToNumeric(value: DataPanelType): int32 {
+        return value as int32
+    }
+    static DataPanelType_FromNumeric(ordinal: int32): DataPanelType {
+        return ordinal as DataPanelType
+    }
+    static DatePickerMode_ToNumeric(value: DatePickerMode): int32 {
+        return value as int32
+    }
+    static DatePickerMode_FromNumeric(ordinal: int32): DatePickerMode {
+        return ordinal as DatePickerMode
+    }
+    static DialogAlignment_ToNumeric(value: DialogAlignment): int32 {
+        return value as int32
+    }
+    static DialogAlignment_FromNumeric(ordinal: int32): DialogAlignment {
+        return ordinal as DialogAlignment
+    }
+    static DialogButtonDirection_ToNumeric(value: DialogButtonDirection): int32 {
+        return value as int32
+    }
+    static DialogButtonDirection_FromNumeric(ordinal: int32): DialogButtonDirection {
+        return ordinal as DialogButtonDirection
+    }
+    static DialogButtonStyle_ToNumeric(value: DialogButtonStyle): int32 {
+        return value as int32
+    }
+    static DialogButtonStyle_FromNumeric(ordinal: int32): DialogButtonStyle {
+        return ordinal as DialogButtonStyle
+    }
+    static Direction_ToNumeric(value: Direction): int32 {
+        return value as int32
+    }
+    static Direction_FromNumeric(ordinal: int32): Direction {
+        return ordinal as Direction
+    }
+    static DismissReason_ToNumeric(value: DismissReason): int32 {
+        return value as int32
+    }
+    static DismissReason_FromNumeric(ordinal: int32): DismissReason {
+        return ordinal as DismissReason
+    }
+    static DistributionType_ToNumeric(value: DistributionType): int32 {
+        return value as int32
+    }
+    static DistributionType_FromNumeric(ordinal: int32): DistributionType {
+        return ordinal as DistributionType
+    }
+    static DisturbanceFieldShape_ToNumeric(value: DisturbanceFieldShape): int32 {
+        return value as int32
+    }
+    static DisturbanceFieldShape_FromNumeric(ordinal: int32): DisturbanceFieldShape {
+        return ordinal as DisturbanceFieldShape
+    }
+    static DividerMode_ToNumeric(value: DividerMode): int32 {
+        return value as int32
+    }
+    static DividerMode_FromNumeric(ordinal: int32): DividerMode {
+        return ordinal as DividerMode
+    }
+    static DpiFollowStrategy_ToNumeric(value: DpiFollowStrategy): int32 {
+        return value as int32
+    }
+    static DpiFollowStrategy_FromNumeric(ordinal: int32): DpiFollowStrategy {
+        return ordinal as DpiFollowStrategy
+    }
+    static DragBehavior_ToNumeric(value: DragBehavior): int32 {
+        return value as int32
+    }
+    static DragBehavior_FromNumeric(ordinal: int32): DragBehavior {
+        return ordinal as DragBehavior
+    }
+    static DraggingSizeChangeEffect_ToNumeric(value: DraggingSizeChangeEffect): int32 {
+        return value as int32
+    }
+    static DraggingSizeChangeEffect_FromNumeric(ordinal: int32): DraggingSizeChangeEffect {
+        return ordinal as DraggingSizeChangeEffect
+    }
+    static DragPreviewMode_ToNumeric(value: DragPreviewMode): int32 {
+        return value as int32
+    }
+    static DragPreviewMode_FromNumeric(ordinal: int32): DragPreviewMode {
+        return ordinal as DragPreviewMode
+    }
+    static DragResult_ToNumeric(value: DragResult): int32 {
+        return value as int32
+    }
+    static DragResult_FromNumeric(ordinal: int32): DragResult {
+        return ordinal as DragResult
+    }
+    static drawing_BlendMode_ToNumeric(value: drawing.BlendMode): int32 {
+        return value as int32
+    }
+    static drawing_BlendMode_FromNumeric(ordinal: int32): drawing.BlendMode {
+        return ordinal as drawing.BlendMode
+    }
+    static drawing_BlurType_ToNumeric(value: drawing.BlurType): int32 {
+        return value as int32
+    }
+    static drawing_BlurType_FromNumeric(ordinal: int32): drawing.BlurType {
+        return ordinal as drawing.BlurType
+    }
+    static drawing_CapStyle_ToNumeric(value: drawing.CapStyle): int32 {
+        return value as int32
+    }
+    static drawing_CapStyle_FromNumeric(ordinal: int32): drawing.CapStyle {
+        return ordinal as drawing.CapStyle
+    }
+    static drawing_ClipOp_ToNumeric(value: drawing.ClipOp): int32 {
+        return value as int32
+    }
+    static drawing_ClipOp_FromNumeric(ordinal: int32): drawing.ClipOp {
+        return ordinal as drawing.ClipOp
+    }
+    static drawing_CornerPos_ToNumeric(value: drawing.CornerPos): int32 {
+        return value as int32
+    }
+    static drawing_CornerPos_FromNumeric(ordinal: int32): drawing.CornerPos {
+        return ordinal as drawing.CornerPos
+    }
+    static drawing_FilterMode_ToNumeric(value: drawing.FilterMode): int32 {
+        return value as int32
+    }
+    static drawing_FilterMode_FromNumeric(ordinal: int32): drawing.FilterMode {
+        return ordinal as drawing.FilterMode
+    }
+    static drawing_FontEdging_ToNumeric(value: drawing.FontEdging): int32 {
+        return value as int32
+    }
+    static drawing_FontEdging_FromNumeric(ordinal: int32): drawing.FontEdging {
+        return ordinal as drawing.FontEdging
+    }
+    static drawing_FontHinting_ToNumeric(value: drawing.FontHinting): int32 {
+        return value as int32
+    }
+    static drawing_FontHinting_FromNumeric(ordinal: int32): drawing.FontHinting {
+        return ordinal as drawing.FontHinting
+    }
+    static drawing_FontMetricsFlags_ToNumeric(value: drawing.FontMetricsFlags): int32 {
+        return value as int32
+    }
+    static drawing_FontMetricsFlags_FromNumeric(ordinal: int32): drawing.FontMetricsFlags {
+        return ordinal as drawing.FontMetricsFlags
+    }
+    static drawing_JoinStyle_ToNumeric(value: drawing.JoinStyle): int32 {
+        return value as int32
+    }
+    static drawing_JoinStyle_FromNumeric(ordinal: int32): drawing.JoinStyle {
+        return ordinal as drawing.JoinStyle
+    }
+    static drawing_PathDirection_ToNumeric(value: drawing.PathDirection): int32 {
+        return value as int32
+    }
+    static drawing_PathDirection_FromNumeric(ordinal: int32): drawing.PathDirection {
+        return ordinal as drawing.PathDirection
+    }
+    static drawing_PathFillType_ToNumeric(value: drawing.PathFillType): int32 {
+        return value as int32
+    }
+    static drawing_PathFillType_FromNumeric(ordinal: int32): drawing.PathFillType {
+        return ordinal as drawing.PathFillType
+    }
+    static drawing_PathMeasureMatrixFlags_ToNumeric(value: drawing.PathMeasureMatrixFlags): int32 {
+        return value as int32
+    }
+    static drawing_PathMeasureMatrixFlags_FromNumeric(ordinal: int32): drawing.PathMeasureMatrixFlags {
+        return ordinal as drawing.PathMeasureMatrixFlags
+    }
+    static drawing_PathOp_ToNumeric(value: drawing.PathOp): int32 {
+        return value as int32
+    }
+    static drawing_PathOp_FromNumeric(ordinal: int32): drawing.PathOp {
+        return ordinal as drawing.PathOp
+    }
+    static drawing_PointMode_ToNumeric(value: drawing.PointMode): int32 {
+        return value as int32
+    }
+    static drawing_PointMode_FromNumeric(ordinal: int32): drawing.PointMode {
+        return ordinal as drawing.PointMode
+    }
+    static drawing_RectType_ToNumeric(value: drawing.RectType): int32 {
+        return value as int32
+    }
+    static drawing_RectType_FromNumeric(ordinal: int32): drawing.RectType {
+        return ordinal as drawing.RectType
+    }
+    static drawing_RegionOp_ToNumeric(value: drawing.RegionOp): int32 {
+        return value as int32
+    }
+    static drawing_RegionOp_FromNumeric(ordinal: int32): drawing.RegionOp {
+        return ordinal as drawing.RegionOp
+    }
+    static drawing_ScaleToFit_ToNumeric(value: drawing.ScaleToFit): int32 {
+        return value as int32
+    }
+    static drawing_ScaleToFit_FromNumeric(ordinal: int32): drawing.ScaleToFit {
+        return ordinal as drawing.ScaleToFit
+    }
+    static drawing_ShadowFlag_ToNumeric(value: drawing.ShadowFlag): int32 {
+        return value as int32
+    }
+    static drawing_ShadowFlag_FromNumeric(ordinal: int32): drawing.ShadowFlag {
+        return ordinal as drawing.ShadowFlag
+    }
+    static drawing_SrcRectConstraint_ToNumeric(value: drawing.SrcRectConstraint): int32 {
+        return value as int32
+    }
+    static drawing_SrcRectConstraint_FromNumeric(ordinal: int32): drawing.SrcRectConstraint {
+        return ordinal as drawing.SrcRectConstraint
+    }
+    static drawing_TextEncoding_ToNumeric(value: drawing.TextEncoding): int32 {
+        return value as int32
+    }
+    static drawing_TextEncoding_FromNumeric(ordinal: int32): drawing.TextEncoding {
+        return ordinal as drawing.TextEncoding
+    }
+    static drawing_TileMode_ToNumeric(value: drawing.TileMode): int32 {
+        return value as int32
+    }
+    static drawing_TileMode_FromNumeric(ordinal: int32): drawing.TileMode {
+        return ordinal as drawing.TileMode
+    }
+    static DynamicRangeMode_ToNumeric(value: DynamicRangeMode): int32 {
+        return value as int32
+    }
+    static DynamicRangeMode_FromNumeric(ordinal: int32): DynamicRangeMode {
+        return ordinal as DynamicRangeMode
+    }
+    static Edge_ToNumeric(value: Edge): int32 {
+        return value as int32
+    }
+    static Edge_FromNumeric(ordinal: int32): Edge {
+        return ordinal as Edge
+    }
+    static EdgeEffect_ToNumeric(value: EdgeEffect): int32 {
+        return value as int32
+    }
+    static EdgeEffect_FromNumeric(ordinal: int32): EdgeEffect {
+        return ordinal as EdgeEffect
+    }
+    static EffectDirection_ToNumeric(value: EffectDirection): int32 {
+        return value as int32
+    }
+    static EffectDirection_FromNumeric(ordinal: int32): EffectDirection {
+        return ordinal as EffectDirection
+    }
+    static EffectEdge_ToNumeric(value: EffectEdge): int32 {
+        return value as int32
+    }
+    static EffectEdge_FromNumeric(ordinal: int32): EffectEdge {
+        return ordinal as EffectEdge
+    }
+    static EffectFillStyle_ToNumeric(value: EffectFillStyle): int32 {
+        return value as int32
+    }
+    static EffectFillStyle_FromNumeric(ordinal: int32): EffectFillStyle {
+        return ordinal as EffectFillStyle
+    }
+    static EffectScope_ToNumeric(value: EffectScope): int32 {
+        return value as int32
+    }
+    static EffectScope_FromNumeric(ordinal: int32): EffectScope {
+        return ordinal as EffectScope
+    }
+    static EffectType_ToNumeric(value: EffectType): int32 {
+        return value as int32
+    }
+    static EffectType_FromNumeric(ordinal: int32): EffectType {
+        return ordinal as EffectType
+    }
+    static EllipsisMode_ToNumeric(value: EllipsisMode): int32 {
+        return value as int32
+    }
+    static EllipsisMode_FromNumeric(ordinal: int32): EllipsisMode {
+        return ordinal as EllipsisMode
+    }
+    static EmbeddedType_ToNumeric(value: EmbeddedType): int32 {
+        return value as int32
+    }
+    static EmbeddedType_FromNumeric(ordinal: int32): EmbeddedType {
+        return ordinal as EmbeddedType
+    }
+    static EnterKeyType_ToNumeric(value: EnterKeyType): int32 {
+        return value as int32
+    }
+    static EnterKeyType_FromNumeric(ordinal: int32): EnterKeyType {
+        return ordinal as EnterKeyType
+    }
+    static FileSelectorMode_ToNumeric(value: FileSelectorMode): int32 {
+        return value as int32
+    }
+    static FileSelectorMode_FromNumeric(ordinal: int32): FileSelectorMode {
+        return ordinal as FileSelectorMode
+    }
+    static FillMode_ToNumeric(value: FillMode): int32 {
+        return value as int32
+    }
+    static FillMode_FromNumeric(ordinal: int32): FillMode {
+        return ordinal as FillMode
+    }
+    static FinishCallbackType_ToNumeric(value: FinishCallbackType): int32 {
+        return value as int32
+    }
+    static FinishCallbackType_FromNumeric(ordinal: int32): FinishCallbackType {
+        return ordinal as FinishCallbackType
+    }
+    static FlexAlign_ToNumeric(value: FlexAlign): int32 {
+        return value as int32
+    }
+    static FlexAlign_FromNumeric(ordinal: int32): FlexAlign {
+        return ordinal as FlexAlign
+    }
+    static FlexDirection_ToNumeric(value: FlexDirection): int32 {
+        return value as int32
+    }
+    static FlexDirection_FromNumeric(ordinal: int32): FlexDirection {
+        return ordinal as FlexDirection
+    }
+    static FlexWrap_ToNumeric(value: FlexWrap): int32 {
+        return value as int32
+    }
+    static FlexWrap_FromNumeric(ordinal: int32): FlexWrap {
+        return ordinal as FlexWrap
+    }
+    static FocusDrawLevel_ToNumeric(value: FocusDrawLevel): int32 {
+        return value as int32
+    }
+    static FocusDrawLevel_FromNumeric(ordinal: int32): FocusDrawLevel {
+        return ordinal as FocusDrawLevel
+    }
+    static FocusPriority_ToNumeric(value: FocusPriority): int32 {
+        return value as int32
+    }
+    static FocusPriority_FromNumeric(ordinal: int32): FocusPriority {
+        return ordinal as FocusPriority
+    }
+    static FoldStatus_ToNumeric(value: FoldStatus): int32 {
+        return value as int32
+    }
+    static FoldStatus_FromNumeric(ordinal: int32): FoldStatus {
+        return ordinal as FoldStatus
+    }
+    static FontStyle_ToNumeric(value: FontStyle): int32 {
+        return value as int32
+    }
+    static FontStyle_FromNumeric(ordinal: int32): FontStyle {
+        return ordinal as FontStyle
+    }
+    static FontWeight_ToNumeric(value: FontWeight): int32 {
+        return value as int32
+    }
+    static FontWeight_FromNumeric(ordinal: int32): FontWeight {
+        return ordinal as FontWeight
+    }
+    static FormDimension_ToNumeric(value: FormDimension): int32 {
+        return value as int32
+    }
+    static FormDimension_FromNumeric(ordinal: int32): FormDimension {
+        return ordinal as FormDimension
+    }
+    static FormRenderingMode_ToNumeric(value: FormRenderingMode): int32 {
+        return value as int32
+    }
+    static FormRenderingMode_FromNumeric(ordinal: int32): FormRenderingMode {
+        return ordinal as FormRenderingMode
+    }
+    static FormShape_ToNumeric(value: FormShape): int32 {
+        return value as int32
+    }
+    static FormShape_FromNumeric(ordinal: int32): FormShape {
+        return ordinal as FormShape
+    }
+    static FunctionKey_ToNumeric(value: FunctionKey): int32 {
+        return value as int32
+    }
+    static FunctionKey_FromNumeric(ordinal: int32): FunctionKey {
+        return ordinal as FunctionKey
+    }
+    static GestureControl_GestureType_ToNumeric(value: GestureControl.GestureType): int32 {
+        return value as int32
+    }
+    static GestureControl_GestureType_FromNumeric(ordinal: int32): GestureControl.GestureType {
+        return ordinal as GestureControl.GestureType
+    }
+    static GestureJudgeResult_ToNumeric(value: GestureJudgeResult): int32 {
+        return value as int32
+    }
+    static GestureJudgeResult_FromNumeric(ordinal: int32): GestureJudgeResult {
+        return ordinal as GestureJudgeResult
+    }
+    static GestureMask_ToNumeric(value: GestureMask): int32 {
+        return value as int32
+    }
+    static GestureMask_FromNumeric(ordinal: int32): GestureMask {
+        return ordinal as GestureMask
+    }
+    static GestureMode_ToNumeric(value: GestureMode): int32 {
+        return value as int32
+    }
+    static GestureMode_FromNumeric(ordinal: int32): GestureMode {
+        return ordinal as GestureMode
+    }
+    static GesturePriority_ToNumeric(value: GesturePriority): int32 {
+        return value as int32
+    }
+    static GesturePriority_FromNumeric(ordinal: int32): GesturePriority {
+        return ordinal as GesturePriority
+    }
+    static GestureRecognizerState_ToNumeric(value: GestureRecognizerState): int32 {
+        return value as int32
+    }
+    static GestureRecognizerState_FromNumeric(ordinal: int32): GestureRecognizerState {
+        return ordinal as GestureRecognizerState
+    }
+    static GradientDirection_ToNumeric(value: GradientDirection): int32 {
+        return value as int32
+    }
+    static GradientDirection_FromNumeric(ordinal: int32): GradientDirection {
+        return ordinal as GradientDirection
+    }
+    static GridDirection_ToNumeric(value: GridDirection): int32 {
+        return value as int32
+    }
+    static GridDirection_FromNumeric(ordinal: int32): GridDirection {
+        return ordinal as GridDirection
+    }
+    static GridItemAlignment_ToNumeric(value: GridItemAlignment): int32 {
+        return value as int32
+    }
+    static GridItemAlignment_FromNumeric(ordinal: int32): GridItemAlignment {
+        return ordinal as GridItemAlignment
+    }
+    static GridItemStyle_ToNumeric(value: GridItemStyle): int32 {
+        return value as int32
+    }
+    static GridItemStyle_FromNumeric(ordinal: int32): GridItemStyle {
+        return ordinal as GridItemStyle
+    }
+    static GridRowDirection_ToNumeric(value: GridRowDirection): int32 {
+        return value as int32
+    }
+    static GridRowDirection_FromNumeric(ordinal: int32): GridRowDirection {
+        return ordinal as GridRowDirection
+    }
+    static HapticFeedbackMode_ToNumeric(value: HapticFeedbackMode): int32 {
+        return value as int32
+    }
+    static HapticFeedbackMode_FromNumeric(ordinal: int32): HapticFeedbackMode {
+        return ordinal as HapticFeedbackMode
+    }
+    static HeightBreakpoint_ToNumeric(value: HeightBreakpoint): int32 {
+        return value as int32
+    }
+    static HeightBreakpoint_FromNumeric(ordinal: int32): HeightBreakpoint {
+        return ordinal as HeightBreakpoint
+    }
+    static HitTestMode_ToNumeric(value: HitTestMode): int32 {
+        return value as int32
+    }
+    static HitTestMode_FromNumeric(ordinal: int32): HitTestMode {
+        return ordinal as HitTestMode
+    }
+    static HitTestType_ToNumeric(value: HitTestType): int32 {
+        return value as int32
+    }
+    static HitTestType_FromNumeric(ordinal: int32): HitTestType {
+        return ordinal as HitTestType
+    }
+    static HorizontalAlign_ToNumeric(value: HorizontalAlign): int32 {
+        return value as int32
+    }
+    static HorizontalAlign_FromNumeric(ordinal: int32): HorizontalAlign {
+        return ordinal as HorizontalAlign
+    }
+    static HoverEffect_ToNumeric(value: HoverEffect): int32 {
+        return value as int32
+    }
+    static HoverEffect_FromNumeric(ordinal: int32): HoverEffect {
+        return ordinal as HoverEffect
+    }
+    static HoverModeAreaType_ToNumeric(value: HoverModeAreaType): int32 {
+        return value as int32
+    }
+    static HoverModeAreaType_FromNumeric(ordinal: int32): HoverModeAreaType {
+        return ordinal as HoverModeAreaType
+    }
+    static IlluminatedType_ToNumeric(value: IlluminatedType): int32 {
+        return value as int32
+    }
+    static IlluminatedType_FromNumeric(ordinal: int32): IlluminatedType {
+        return ordinal as IlluminatedType
+    }
+    static image_ResolutionQuality_ToNumeric(value: image.ResolutionQuality): int32 {
+        return value as int32
+    }
+    static image_ResolutionQuality_FromNumeric(ordinal: int32): image.ResolutionQuality {
+        return ordinal as image.ResolutionQuality
+    }
+    static ImageAnalyzerType_ToNumeric(value: ImageAnalyzerType): int32 {
+        return value as int32
+    }
+    static ImageAnalyzerType_FromNumeric(ordinal: int32): ImageAnalyzerType {
+        return ordinal as ImageAnalyzerType
+    }
+    static ImageContent_ToNumeric(value: ImageContent): int32 {
+        return value as int32
+    }
+    static ImageContent_FromNumeric(ordinal: int32): ImageContent {
+        return ordinal as ImageContent
+    }
+    static ImageFit_ToNumeric(value: ImageFit): int32 {
+        return value as int32
+    }
+    static ImageFit_FromNumeric(ordinal: int32): ImageFit {
+        return ordinal as ImageFit
+    }
+    static ImageInterpolation_ToNumeric(value: ImageInterpolation): int32 {
+        return value as int32
+    }
+    static ImageInterpolation_FromNumeric(ordinal: int32): ImageInterpolation {
+        return ordinal as ImageInterpolation
+    }
+    static ImageRenderMode_ToNumeric(value: ImageRenderMode): int32 {
+        return value as int32
+    }
+    static ImageRenderMode_FromNumeric(ordinal: int32): ImageRenderMode {
+        return ordinal as ImageRenderMode
+    }
+    static ImageRepeat_ToNumeric(value: ImageRepeat): int32 {
+        return value as int32
+    }
+    static ImageRepeat_FromNumeric(ordinal: int32): ImageRepeat {
+        return ordinal as ImageRepeat
+    }
+    static ImageRotateOrientation_ToNumeric(value: ImageRotateOrientation): int32 {
+        return value as int32
+    }
+    static ImageRotateOrientation_FromNumeric(ordinal: int32): ImageRotateOrientation {
+        return ordinal as ImageRotateOrientation
+    }
+    static ImageSize_ToNumeric(value: ImageSize): int32 {
+        return value as int32
+    }
+    static ImageSize_FromNumeric(ordinal: int32): ImageSize {
+        return ordinal as ImageSize
+    }
+    static ImageSpanAlignment_ToNumeric(value: ImageSpanAlignment): int32 {
+        return value as int32
+    }
+    static ImageSpanAlignment_FromNumeric(ordinal: int32): ImageSpanAlignment {
+        return ordinal as ImageSpanAlignment
+    }
+    static ImmersiveMode_ToNumeric(value: ImmersiveMode): int32 {
+        return value as int32
+    }
+    static ImmersiveMode_FromNumeric(ordinal: int32): ImmersiveMode {
+        return ordinal as ImmersiveMode
+    }
+    static IndexerAlign_ToNumeric(value: IndexerAlign): int32 {
+        return value as int32
+    }
+    static IndexerAlign_FromNumeric(ordinal: int32): IndexerAlign {
+        return ordinal as IndexerAlign
+    }
+    static InputType_ToNumeric(value: InputType): int32 {
+        return value as int32
+    }
+    static InputType_FromNumeric(ordinal: int32): InputType {
+        return ordinal as InputType
+    }
+    static IntentionCode_ToNumeric(value: IntentionCode): int32 {
+        return value as int32
+    }
+    static IntentionCode_FromNumeric(ordinal: int32): IntentionCode {
+        return ordinal as IntentionCode
+    }
+    static InteractionHand_ToNumeric(value: InteractionHand): int32 {
+        return value as int32
+    }
+    static InteractionHand_FromNumeric(ordinal: int32): InteractionHand {
+        return ordinal as InteractionHand
+    }
+    static ItemAlign_ToNumeric(value: ItemAlign): int32 {
+        return value as int32
+    }
+    static ItemAlign_FromNumeric(ordinal: int32): ItemAlign {
+        return ordinal as ItemAlign
+    }
+    static ItemState_ToNumeric(value: ItemState): int32 {
+        return value as int32
+    }
+    static ItemState_FromNumeric(ordinal: int32): ItemState {
+        return ordinal as ItemState
+    }
+    static KeyboardAppearance_ToNumeric(value: KeyboardAppearance): int32 {
+        return value as int32
+    }
+    static KeyboardAppearance_FromNumeric(ordinal: int32): KeyboardAppearance {
+        return ordinal as KeyboardAppearance
+    }
+    static KeyboardAvoidMode_ToNumeric(value: KeyboardAvoidMode): int32 {
+        return value as int32
+    }
+    static KeyboardAvoidMode_FromNumeric(ordinal: int32): KeyboardAvoidMode {
+        return ordinal as KeyboardAvoidMode
+    }
+    static KeyProcessingMode_ToNumeric(value: KeyProcessingMode): int32 {
+        return value as int32
+    }
+    static KeyProcessingMode_FromNumeric(ordinal: int32): KeyProcessingMode {
+        return ordinal as KeyProcessingMode
+    }
+    static KeySource_ToNumeric(value: KeySource): int32 {
+        return value as int32
+    }
+    static KeySource_FromNumeric(ordinal: int32): KeySource {
+        return ordinal as KeySource
+    }
+    static KeyType_ToNumeric(value: KeyType): int32 {
+        return value as int32
+    }
+    static KeyType_FromNumeric(ordinal: int32): KeyType {
+        return ordinal as KeyType
+    }
+    static LaunchMode_ToNumeric(value: LaunchMode): int32 {
+        return value as int32
+    }
+    static LaunchMode_FromNumeric(ordinal: int32): LaunchMode {
+        return ordinal as LaunchMode
+    }
+    static LayoutDirection_ToNumeric(value: LayoutDirection): int32 {
+        return value as int32
+    }
+    static LayoutDirection_FromNumeric(ordinal: int32): LayoutDirection {
+        return ordinal as LayoutDirection
+    }
+    static LayoutMode_ToNumeric(value: LayoutMode): int32 {
+        return value as int32
+    }
+    static LayoutMode_FromNumeric(ordinal: int32): LayoutMode {
+        return ordinal as LayoutMode
+    }
+    static LayoutSafeAreaEdge_ToNumeric(value: LayoutSafeAreaEdge): int32 {
+        return value as int32
+    }
+    static LayoutSafeAreaEdge_FromNumeric(ordinal: int32): LayoutSafeAreaEdge {
+        return ordinal as LayoutSafeAreaEdge
+    }
+    static LayoutSafeAreaType_ToNumeric(value: LayoutSafeAreaType): int32 {
+        return value as int32
+    }
+    static LayoutSafeAreaType_FromNumeric(ordinal: int32): LayoutSafeAreaType {
+        return ordinal as LayoutSafeAreaType
+    }
+    static LayoutStyle_ToNumeric(value: LayoutStyle): int32 {
+        return value as int32
+    }
+    static LayoutStyle_FromNumeric(ordinal: int32): LayoutStyle {
+        return ordinal as LayoutStyle
+    }
+    static LengthMetricsUnit_ToNumeric(value: LengthMetricsUnit): int32 {
+        return value as int32
+    }
+    static LengthMetricsUnit_FromNumeric(ordinal: int32): LengthMetricsUnit {
+        return ordinal as LengthMetricsUnit
+    }
+    static LengthUnit_ToNumeric(value: LengthUnit): int32 {
+        return value as int32
+    }
+    static LengthUnit_FromNumeric(ordinal: int32): LengthUnit {
+        return ordinal as LengthUnit
+    }
+    static LevelMode_ToNumeric(value: LevelMode): int32 {
+        return value as int32
+    }
+    static LevelMode_FromNumeric(ordinal: int32): LevelMode {
+        return ordinal as LevelMode
+    }
+    static LineBreakStrategy_ToNumeric(value: LineBreakStrategy): int32 {
+        return value as int32
+    }
+    static LineBreakStrategy_FromNumeric(ordinal: int32): LineBreakStrategy {
+        return ordinal as LineBreakStrategy
+    }
+    static LineCapStyle_ToNumeric(value: LineCapStyle): int32 {
+        return value as int32
+    }
+    static LineCapStyle_FromNumeric(ordinal: int32): LineCapStyle {
+        return ordinal as LineCapStyle
+    }
+    static LineJoinStyle_ToNumeric(value: LineJoinStyle): int32 {
+        return value as int32
+    }
+    static LineJoinStyle_FromNumeric(ordinal: int32): LineJoinStyle {
+        return ordinal as LineJoinStyle
+    }
+    static ListItemAlign_ToNumeric(value: ListItemAlign): int32 {
+        return value as int32
+    }
+    static ListItemAlign_FromNumeric(ordinal: int32): ListItemAlign {
+        return ordinal as ListItemAlign
+    }
+    static ListItemGroupArea_ToNumeric(value: ListItemGroupArea): int32 {
+        return value as int32
+    }
+    static ListItemGroupArea_FromNumeric(ordinal: int32): ListItemGroupArea {
+        return ordinal as ListItemGroupArea
+    }
+    static ListItemGroupStyle_ToNumeric(value: ListItemGroupStyle): int32 {
+        return value as int32
+    }
+    static ListItemGroupStyle_FromNumeric(ordinal: int32): ListItemGroupStyle {
+        return ordinal as ListItemGroupStyle
+    }
+    static ListItemStyle_ToNumeric(value: ListItemStyle): int32 {
+        return value as int32
+    }
+    static ListItemStyle_FromNumeric(ordinal: int32): ListItemStyle {
+        return ordinal as ListItemStyle
+    }
+    static LoadingProgressStyle_ToNumeric(value: LoadingProgressStyle): int32 {
+        return value as int32
+    }
+    static LoadingProgressStyle_FromNumeric(ordinal: int32): LoadingProgressStyle {
+        return ordinal as LoadingProgressStyle
+    }
+    static LocalizedBarrierDirection_ToNumeric(value: LocalizedBarrierDirection): int32 {
+        return value as int32
+    }
+    static LocalizedBarrierDirection_FromNumeric(ordinal: int32): LocalizedBarrierDirection {
+        return ordinal as LocalizedBarrierDirection
+    }
+    static LocationButtonOnClickResult_ToNumeric(value: LocationButtonOnClickResult): int32 {
+        return value as int32
+    }
+    static LocationButtonOnClickResult_FromNumeric(ordinal: int32): LocationButtonOnClickResult {
+        return ordinal as LocationButtonOnClickResult
+    }
+    static LocationDescription_ToNumeric(value: LocationDescription): int32 {
+        return value as int32
+    }
+    static LocationDescription_FromNumeric(ordinal: int32): LocationDescription {
+        return ordinal as LocationDescription
+    }
+    static LocationIconStyle_ToNumeric(value: LocationIconStyle): int32 {
+        return value as int32
+    }
+    static LocationIconStyle_FromNumeric(ordinal: int32): LocationIconStyle {
+        return ordinal as LocationIconStyle
+    }
+    static MarqueeStartPolicy_ToNumeric(value: MarqueeStartPolicy): int32 {
+        return value as int32
+    }
+    static MarqueeStartPolicy_FromNumeric(ordinal: int32): MarqueeStartPolicy {
+        return ordinal as MarqueeStartPolicy
+    }
+    static MarqueeState_ToNumeric(value: MarqueeState): int32 {
+        return value as int32
+    }
+    static MarqueeState_FromNumeric(ordinal: int32): MarqueeState {
+        return ordinal as MarqueeState
+    }
+    static MarqueeUpdateStrategy_ToNumeric(value: MarqueeUpdateStrategy): int32 {
+        return value as int32
+    }
+    static MarqueeUpdateStrategy_FromNumeric(ordinal: int32): MarqueeUpdateStrategy {
+        return ordinal as MarqueeUpdateStrategy
+    }
+    static MenuAlignType_ToNumeric(value: MenuAlignType): int32 {
+        return value as int32
+    }
+    static MenuAlignType_FromNumeric(ordinal: int32): MenuAlignType {
+        return ordinal as MenuAlignType
+    }
+    static MenuPolicy_ToNumeric(value: MenuPolicy): int32 {
+        return value as int32
+    }
+    static MenuPolicy_FromNumeric(ordinal: int32): MenuPolicy {
+        return ordinal as MenuPolicy
+    }
+    static MenuPreviewMode_ToNumeric(value: MenuPreviewMode): int32 {
+        return value as int32
+    }
+    static MenuPreviewMode_FromNumeric(ordinal: int32): MenuPreviewMode {
+        return ordinal as MenuPreviewMode
+    }
+    static MenuType_ToNumeric(value: MenuType): int32 {
+        return value as int32
+    }
+    static MenuType_FromNumeric(ordinal: int32): MenuType {
+        return ordinal as MenuType
+    }
+    static MessageLevel_ToNumeric(value: MessageLevel): int32 {
+        return value as int32
+    }
+    static MessageLevel_FromNumeric(ordinal: int32): MessageLevel {
+        return ordinal as MessageLevel
+    }
+    static MixedMode_ToNumeric(value: MixedMode): int32 {
+        return value as int32
+    }
+    static MixedMode_FromNumeric(ordinal: int32): MixedMode {
+        return ordinal as MixedMode
+    }
+    static ModalTransition_ToNumeric(value: ModalTransition): int32 {
+        return value as int32
+    }
+    static ModalTransition_FromNumeric(ordinal: int32): ModalTransition {
+        return ordinal as ModalTransition
+    }
+    static ModifierKey_ToNumeric(value: ModifierKey): int32 {
+        return value as int32
+    }
+    static ModifierKey_FromNumeric(ordinal: int32): ModifierKey {
+        return ordinal as ModifierKey
+    }
+    static MouseAction_ToNumeric(value: MouseAction): int32 {
+        return value as int32
+    }
+    static MouseAction_FromNumeric(ordinal: int32): MouseAction {
+        return ordinal as MouseAction
+    }
+    static MouseButton_ToNumeric(value: MouseButton): int32 {
+        return value as int32
+    }
+    static MouseButton_FromNumeric(ordinal: int32): MouseButton {
+        return ordinal as MouseButton
+    }
+    static NativeEmbedStatus_ToNumeric(value: NativeEmbedStatus): int32 {
+        return value as int32
+    }
+    static NativeEmbedStatus_FromNumeric(ordinal: int32): NativeEmbedStatus {
+        return ordinal as NativeEmbedStatus
+    }
+    static NavBarPosition_ToNumeric(value: NavBarPosition): int32 {
+        return value as int32
+    }
+    static NavBarPosition_FromNumeric(ordinal: int32): NavBarPosition {
+        return ordinal as NavBarPosition
+    }
+    static NavDestinationActiveReason_ToNumeric(value: NavDestinationActiveReason): int32 {
+        return value as int32
+    }
+    static NavDestinationActiveReason_FromNumeric(ordinal: int32): NavDestinationActiveReason {
+        return ordinal as NavDestinationActiveReason
+    }
+    static NavDestinationMode_ToNumeric(value: NavDestinationMode): int32 {
+        return value as int32
+    }
+    static NavDestinationMode_FromNumeric(ordinal: int32): NavDestinationMode {
+        return ordinal as NavDestinationMode
+    }
+    static NavigationMode_ToNumeric(value: NavigationMode): int32 {
+        return value as int32
+    }
+    static NavigationMode_FromNumeric(ordinal: int32): NavigationMode {
+        return ordinal as NavigationMode
+    }
+    static NavigationOperation_ToNumeric(value: NavigationOperation): int32 {
+        return value as int32
+    }
+    static NavigationOperation_FromNumeric(ordinal: int32): NavigationOperation {
+        return ordinal as NavigationOperation
+    }
+    static NavigationSystemTransitionType_ToNumeric(value: NavigationSystemTransitionType): int32 {
+        return value as int32
+    }
+    static NavigationSystemTransitionType_FromNumeric(ordinal: int32): NavigationSystemTransitionType {
+        return ordinal as NavigationSystemTransitionType
+    }
+    static NavigationTitleMode_ToNumeric(value: NavigationTitleMode): int32 {
+        return value as int32
+    }
+    static NavigationTitleMode_FromNumeric(ordinal: int32): NavigationTitleMode {
+        return ordinal as NavigationTitleMode
+    }
+    static NavigationType_ToNumeric(value: NavigationType): int32 {
+        return value as int32
+    }
+    static NavigationType_FromNumeric(ordinal: int32): NavigationType {
+        return ordinal as NavigationType
+    }
+    static NestedScrollMode_ToNumeric(value: NestedScrollMode): int32 {
+        return value as int32
+    }
+    static NestedScrollMode_FromNumeric(ordinal: int32): NestedScrollMode {
+        return ordinal as NestedScrollMode
+    }
+    static ObscuredReasons_ToNumeric(value: ObscuredReasons): int32 {
+        return value as int32
+    }
+    static ObscuredReasons_FromNumeric(ordinal: int32): ObscuredReasons {
+        return ordinal as ObscuredReasons
+    }
+    static OptionWidthMode_ToNumeric(value: OptionWidthMode): int32 {
+        return value as int32
+    }
+    static OptionWidthMode_FromNumeric(ordinal: int32): OptionWidthMode {
+        return ordinal as OptionWidthMode
+    }
+    static OutlineStyle_ToNumeric(value: OutlineStyle): int32 {
+        return value as int32
+    }
+    static OutlineStyle_FromNumeric(ordinal: int32): OutlineStyle {
+        return ordinal as OutlineStyle
+    }
+    static OverScrollMode_ToNumeric(value: OverScrollMode): int32 {
+        return value as int32
+    }
+    static OverScrollMode_FromNumeric(ordinal: int32): OverScrollMode {
+        return ordinal as OverScrollMode
+    }
+    static PageFlipMode_ToNumeric(value: PageFlipMode): int32 {
+        return value as int32
+    }
+    static PageFlipMode_FromNumeric(ordinal: int32): PageFlipMode {
+        return ordinal as PageFlipMode
+    }
+    static PanDirection_ToNumeric(value: PanDirection): int32 {
+        return value as int32
+    }
+    static PanDirection_FromNumeric(ordinal: int32): PanDirection {
+        return ordinal as PanDirection
+    }
+    static ParticleEmitterShape_ToNumeric(value: ParticleEmitterShape): int32 {
+        return value as int32
+    }
+    static ParticleEmitterShape_FromNumeric(ordinal: int32): ParticleEmitterShape {
+        return ordinal as ParticleEmitterShape
+    }
+    static ParticleType_ToNumeric(value: ParticleType): int32 {
+        return value as int32
+    }
+    static ParticleType_FromNumeric(ordinal: int32): ParticleType {
+        return ordinal as ParticleType
+    }
+    static ParticleUpdater_ToNumeric(value: ParticleUpdater): int32 {
+        return value as int32
+    }
+    static ParticleUpdater_FromNumeric(ordinal: int32): ParticleUpdater {
+        return ordinal as ParticleUpdater
+    }
+    static PasteButtonOnClickResult_ToNumeric(value: PasteButtonOnClickResult): int32 {
+        return value as int32
+    }
+    static PasteButtonOnClickResult_FromNumeric(ordinal: int32): PasteButtonOnClickResult {
+        return ordinal as PasteButtonOnClickResult
+    }
+    static PasteDescription_ToNumeric(value: PasteDescription): int32 {
+        return value as int32
+    }
+    static PasteDescription_FromNumeric(ordinal: int32): PasteDescription {
+        return ordinal as PasteDescription
+    }
+    static PasteIconStyle_ToNumeric(value: PasteIconStyle): int32 {
+        return value as int32
+    }
+    static PasteIconStyle_FromNumeric(ordinal: int32): PasteIconStyle {
+        return ordinal as PasteIconStyle
+    }
+    static PatternLockChallengeResult_ToNumeric(value: PatternLockChallengeResult): int32 {
+        return value as int32
+    }
+    static PatternLockChallengeResult_FromNumeric(ordinal: int32): PatternLockChallengeResult {
+        return ordinal as PatternLockChallengeResult
+    }
+    static PerfMonitorActionType_ToNumeric(value: PerfMonitorActionType): int32 {
+        return value as int32
+    }
+    static PerfMonitorActionType_FromNumeric(ordinal: int32): PerfMonitorActionType {
+        return ordinal as PerfMonitorActionType
+    }
+    static PerfMonitorSourceType_ToNumeric(value: PerfMonitorSourceType): int32 {
+        return value as int32
+    }
+    static PerfMonitorSourceType_FromNumeric(ordinal: int32): PerfMonitorSourceType {
+        return ordinal as PerfMonitorSourceType
+    }
+    static PixelRoundCalcPolicy_ToNumeric(value: PixelRoundCalcPolicy): int32 {
+        return value as int32
+    }
+    static PixelRoundCalcPolicy_FromNumeric(ordinal: int32): PixelRoundCalcPolicy {
+        return ordinal as PixelRoundCalcPolicy
+    }
+    static PixelRoundMode_ToNumeric(value: PixelRoundMode): int32 {
+        return value as int32
+    }
+    static PixelRoundMode_FromNumeric(ordinal: int32): PixelRoundMode {
+        return ordinal as PixelRoundMode
+    }
+    static Placement_ToNumeric(value: Placement): int32 {
+        return value as int32
+    }
+    static Placement_FromNumeric(ordinal: int32): Placement {
+        return ordinal as Placement
+    }
+    static PlaybackSpeed_ToNumeric(value: PlaybackSpeed): int32 {
+        return value as int32
+    }
+    static PlaybackSpeed_FromNumeric(ordinal: int32): PlaybackSpeed {
+        return ordinal as PlaybackSpeed
+    }
+    static PlayMode_ToNumeric(value: PlayMode): int32 {
+        return value as int32
+    }
+    static PlayMode_FromNumeric(ordinal: int32): PlayMode {
+        return ordinal as PlayMode
+    }
+    static pointer_PointerStyle_ToNumeric(value: pointer.PointerStyle): int32 {
+        return value as int32
+    }
+    static pointer_PointerStyle_FromNumeric(ordinal: int32): pointer.PointerStyle {
+        return ordinal as pointer.PointerStyle
+    }
+    static PreDragStatus_ToNumeric(value: PreDragStatus): int32 {
+        return value as int32
+    }
+    static PreDragStatus_FromNumeric(ordinal: int32): PreDragStatus {
+        return ordinal as PreDragStatus
+    }
+    static ProgressStatus_ToNumeric(value: ProgressStatus): int32 {
+        return value as int32
+    }
+    static ProgressStatus_FromNumeric(ordinal: int32): ProgressStatus {
+        return ordinal as ProgressStatus
+    }
+    static ProgressStyle_ToNumeric(value: ProgressStyle): int32 {
+        return value as int32
+    }
+    static ProgressStyle_FromNumeric(ordinal: int32): ProgressStyle {
+        return ordinal as ProgressStyle
+    }
+    static ProgressType_ToNumeric(value: ProgressType): int32 {
+        return value as int32
+    }
+    static ProgressType_FromNumeric(ordinal: int32): ProgressType {
+        return ordinal as ProgressType
+    }
+    static ProtectedResourceType_ToNumeric(value: ProtectedResourceType): int32 {
+        return value as int32
+    }
+    static ProtectedResourceType_FromNumeric(ordinal: int32): ProtectedResourceType {
+        return ordinal as ProtectedResourceType
+    }
+    static RadioIndicatorType_ToNumeric(value: RadioIndicatorType): int32 {
+        return value as int32
+    }
+    static RadioIndicatorType_FromNumeric(ordinal: int32): RadioIndicatorType {
+        return ordinal as RadioIndicatorType
+    }
+    static RefreshStatus_ToNumeric(value: RefreshStatus): int32 {
+        return value as int32
+    }
+    static RefreshStatus_FromNumeric(ordinal: int32): RefreshStatus {
+        return ordinal as RefreshStatus
+    }
+    static RelateType_ToNumeric(value: RelateType): int32 {
+        return value as int32
+    }
+    static RelateType_FromNumeric(ordinal: int32): RelateType {
+        return ordinal as RelateType
+    }
+    static RenderExitReason_ToNumeric(value: RenderExitReason): int32 {
+        return value as int32
+    }
+    static RenderExitReason_FromNumeric(ordinal: int32): RenderExitReason {
+        return ordinal as RenderExitReason
+    }
+    static RenderFit_ToNumeric(value: RenderFit): int32 {
+        return value as int32
+    }
+    static RenderFit_FromNumeric(ordinal: int32): RenderFit {
+        return ordinal as RenderFit
+    }
+    static RenderMode_ToNumeric(value: RenderMode): int32 {
+        return value as int32
+    }
+    static RenderMode_FromNumeric(ordinal: int32): RenderMode {
+        return ordinal as RenderMode
+    }
+    static RenderProcessNotRespondingReason_ToNumeric(value: RenderProcessNotRespondingReason): int32 {
+        return value as int32
+    }
+    static RenderProcessNotRespondingReason_FromNumeric(ordinal: int32): RenderProcessNotRespondingReason {
+        return ordinal as RenderProcessNotRespondingReason
+    }
+    static RepeatMode_ToNumeric(value: RepeatMode): int32 {
+        return value as int32
+    }
+    static RepeatMode_FromNumeric(ordinal: int32): RepeatMode {
+        return ordinal as RepeatMode
+    }
+    static ResponseType_ToNumeric(value: ResponseType): int32 {
+        return value as int32
+    }
+    static ResponseType_FromNumeric(ordinal: int32): ResponseType {
+        return ordinal as ResponseType
+    }
+    static RichEditorDeleteDirection_ToNumeric(value: RichEditorDeleteDirection): int32 {
+        return value as int32
+    }
+    static RichEditorDeleteDirection_FromNumeric(ordinal: int32): RichEditorDeleteDirection {
+        return ordinal as RichEditorDeleteDirection
+    }
+    static RichEditorResponseType_ToNumeric(value: RichEditorResponseType): int32 {
+        return value as int32
+    }
+    static RichEditorResponseType_FromNumeric(ordinal: int32): RichEditorResponseType {
+        return ordinal as RichEditorResponseType
+    }
+    static RichEditorSpanType_ToNumeric(value: RichEditorSpanType): int32 {
+        return value as int32
+    }
+    static RichEditorSpanType_FromNumeric(ordinal: int32): RichEditorSpanType {
+        return ordinal as RichEditorSpanType
+    }
+    static RouteType_ToNumeric(value: RouteType): int32 {
+        return value as int32
+    }
+    static RouteType_FromNumeric(ordinal: int32): RouteType {
+        return ordinal as RouteType
+    }
+    static SafeAreaEdge_ToNumeric(value: SafeAreaEdge): int32 {
+        return value as int32
+    }
+    static SafeAreaEdge_FromNumeric(ordinal: int32): SafeAreaEdge {
+        return ordinal as SafeAreaEdge
+    }
+    static SafeAreaType_ToNumeric(value: SafeAreaType): int32 {
+        return value as int32
+    }
+    static SafeAreaType_FromNumeric(ordinal: int32): SafeAreaType {
+        return ordinal as SafeAreaType
+    }
+    static SaveButtonOnClickResult_ToNumeric(value: SaveButtonOnClickResult): int32 {
+        return value as int32
+    }
+    static SaveButtonOnClickResult_FromNumeric(ordinal: int32): SaveButtonOnClickResult {
+        return ordinal as SaveButtonOnClickResult
+    }
+    static SaveDescription_ToNumeric(value: SaveDescription): int32 {
+        return value as int32
+    }
+    static SaveDescription_FromNumeric(ordinal: int32): SaveDescription {
+        return ordinal as SaveDescription
+    }
+    static SaveIconStyle_ToNumeric(value: SaveIconStyle): int32 {
+        return value as int32
+    }
+    static SaveIconStyle_FromNumeric(ordinal: int32): SaveIconStyle {
+        return ordinal as SaveIconStyle
+    }
+    static ScrollAlign_ToNumeric(value: ScrollAlign): int32 {
+        return value as int32
+    }
+    static ScrollAlign_FromNumeric(ordinal: int32): ScrollAlign {
+        return ordinal as ScrollAlign
+    }
+    static ScrollBarDirection_ToNumeric(value: ScrollBarDirection): int32 {
+        return value as int32
+    }
+    static ScrollBarDirection_FromNumeric(ordinal: int32): ScrollBarDirection {
+        return ordinal as ScrollBarDirection
+    }
+    static ScrollDirection_ToNumeric(value: ScrollDirection): int32 {
+        return value as int32
+    }
+    static ScrollDirection_FromNumeric(ordinal: int32): ScrollDirection {
+        return ordinal as ScrollDirection
+    }
+    static ScrollSizeMode_ToNumeric(value: ScrollSizeMode): int32 {
+        return value as int32
+    }
+    static ScrollSizeMode_FromNumeric(ordinal: int32): ScrollSizeMode {
+        return ordinal as ScrollSizeMode
+    }
+    static ScrollSnapAlign_ToNumeric(value: ScrollSnapAlign): int32 {
+        return value as int32
+    }
+    static ScrollSnapAlign_FromNumeric(ordinal: int32): ScrollSnapAlign {
+        return ordinal as ScrollSnapAlign
+    }
+    static ScrollSource_ToNumeric(value: ScrollSource): int32 {
+        return value as int32
+    }
+    static ScrollSource_FromNumeric(ordinal: int32): ScrollSource {
+        return ordinal as ScrollSource
+    }
+    static ScrollState_ToNumeric(value: ScrollState): int32 {
+        return value as int32
+    }
+    static ScrollState_FromNumeric(ordinal: int32): ScrollState {
+        return ordinal as ScrollState
+    }
+    static SearchType_ToNumeric(value: SearchType): int32 {
+        return value as int32
+    }
+    static SearchType_FromNumeric(ordinal: int32): SearchType {
+        return ordinal as SearchType
+    }
+    static SecurityComponentLayoutDirection_ToNumeric(value: SecurityComponentLayoutDirection): int32 {
+        return value as int32
+    }
+    static SecurityComponentLayoutDirection_FromNumeric(ordinal: int32): SecurityComponentLayoutDirection {
+        return ordinal as SecurityComponentLayoutDirection
+    }
+    static SeekMode_ToNumeric(value: SeekMode): int32 {
+        return value as int32
+    }
+    static SeekMode_FromNumeric(ordinal: int32): SeekMode {
+        return ordinal as SeekMode
+    }
+    static SelectedMode_ToNumeric(value: SelectedMode): int32 {
+        return value as int32
+    }
+    static SelectedMode_FromNumeric(ordinal: int32): SelectedMode {
+        return ordinal as SelectedMode
+    }
+    static SelectStatus_ToNumeric(value: SelectStatus): int32 {
+        return value as int32
+    }
+    static SelectStatus_FromNumeric(ordinal: int32): SelectStatus {
+        return ordinal as SelectStatus
+    }
+    static ShadowStyle_ToNumeric(value: ShadowStyle): int32 {
+        return value as int32
+    }
+    static ShadowStyle_FromNumeric(ordinal: int32): ShadowStyle {
+        return ordinal as ShadowStyle
+    }
+    static ShadowType_ToNumeric(value: ShadowType): int32 {
+        return value as int32
+    }
+    static ShadowType_FromNumeric(ordinal: int32): ShadowType {
+        return ordinal as ShadowType
+    }
+    static SharedTransitionEffectType_ToNumeric(value: SharedTransitionEffectType): int32 {
+        return value as int32
+    }
+    static SharedTransitionEffectType_FromNumeric(ordinal: int32): SharedTransitionEffectType {
+        return ordinal as SharedTransitionEffectType
+    }
+    static SheetKeyboardAvoidMode_ToNumeric(value: SheetKeyboardAvoidMode): int32 {
+        return value as int32
+    }
+    static SheetKeyboardAvoidMode_FromNumeric(ordinal: int32): SheetKeyboardAvoidMode {
+        return ordinal as SheetKeyboardAvoidMode
+    }
+    static SheetMode_ToNumeric(value: SheetMode): int32 {
+        return value as int32
+    }
+    static SheetMode_FromNumeric(ordinal: int32): SheetMode {
+        return ordinal as SheetMode
+    }
+    static SheetSize_ToNumeric(value: SheetSize): int32 {
+        return value as int32
+    }
+    static SheetSize_FromNumeric(ordinal: int32): SheetSize {
+        return ordinal as SheetSize
+    }
+    static SheetType_ToNumeric(value: SheetType): int32 {
+        return value as int32
+    }
+    static SheetType_FromNumeric(ordinal: int32): SheetType {
+        return ordinal as SheetType
+    }
+    static SideBarContainerType_ToNumeric(value: SideBarContainerType): int32 {
+        return value as int32
+    }
+    static SideBarContainerType_FromNumeric(ordinal: int32): SideBarContainerType {
+        return ordinal as SideBarContainerType
+    }
+    static SideBarPosition_ToNumeric(value: SideBarPosition): int32 {
+        return value as int32
+    }
+    static SideBarPosition_FromNumeric(ordinal: int32): SideBarPosition {
+        return ordinal as SideBarPosition
+    }
+    static SlideEffect_ToNumeric(value: SlideEffect): int32 {
+        return value as int32
+    }
+    static SlideEffect_FromNumeric(ordinal: int32): SlideEffect {
+        return ordinal as SlideEffect
+    }
+    static SliderBlockType_ToNumeric(value: SliderBlockType): int32 {
+        return value as int32
+    }
+    static SliderBlockType_FromNumeric(ordinal: int32): SliderBlockType {
+        return ordinal as SliderBlockType
+    }
+    static SliderChangeMode_ToNumeric(value: SliderChangeMode): int32 {
+        return value as int32
+    }
+    static SliderChangeMode_FromNumeric(ordinal: int32): SliderChangeMode {
+        return ordinal as SliderChangeMode
+    }
+    static SliderInteraction_ToNumeric(value: SliderInteraction): int32 {
+        return value as int32
+    }
+    static SliderInteraction_FromNumeric(ordinal: int32): SliderInteraction {
+        return ordinal as SliderInteraction
+    }
+    static SliderStyle_ToNumeric(value: SliderStyle): int32 {
+        return value as int32
+    }
+    static SliderStyle_FromNumeric(ordinal: int32): SliderStyle {
+        return ordinal as SliderStyle
+    }
+    static SourceTool_ToNumeric(value: SourceTool): int32 {
+        return value as int32
+    }
+    static SourceTool_FromNumeric(ordinal: int32): SourceTool {
+        return ordinal as SourceTool
+    }
+    static SourceType_ToNumeric(value: SourceType): int32 {
+        return value as int32
+    }
+    static SourceType_FromNumeric(ordinal: int32): SourceType {
+        return ordinal as SourceType
+    }
+    static SslError_ToNumeric(value: SslError): int32 {
+        return value as int32
+    }
+    static SslError_FromNumeric(ordinal: int32): SslError {
+        return ordinal as SslError
+    }
+    static StickyStyle_ToNumeric(value: StickyStyle): int32 {
+        return value as int32
+    }
+    static StickyStyle_FromNumeric(ordinal: int32): StickyStyle {
+        return ordinal as StickyStyle
+    }
+    static StyledStringKey_ToNumeric(value: StyledStringKey): int32 {
+        return value as int32
+    }
+    static StyledStringKey_FromNumeric(ordinal: int32): StyledStringKey {
+        return ordinal as StyledStringKey
+    }
+    static SubMenuExpandingMode_ToNumeric(value: SubMenuExpandingMode): int32 {
+        return value as int32
+    }
+    static SubMenuExpandingMode_FromNumeric(ordinal: int32): SubMenuExpandingMode {
+        return ordinal as SubMenuExpandingMode
+    }
+    static SwipeActionState_ToNumeric(value: SwipeActionState): int32 {
+        return value as int32
+    }
+    static SwipeActionState_FromNumeric(ordinal: int32): SwipeActionState {
+        return ordinal as SwipeActionState
+    }
+    static SwipeDirection_ToNumeric(value: SwipeDirection): int32 {
+        return value as int32
+    }
+    static SwipeDirection_FromNumeric(ordinal: int32): SwipeDirection {
+        return ordinal as SwipeDirection
+    }
+    static SwipeEdgeEffect_ToNumeric(value: SwipeEdgeEffect): int32 {
+        return value as int32
+    }
+    static SwipeEdgeEffect_FromNumeric(ordinal: int32): SwipeEdgeEffect {
+        return ordinal as SwipeEdgeEffect
+    }
+    static SwiperAnimationMode_ToNumeric(value: SwiperAnimationMode): int32 {
+        return value as int32
+    }
+    static SwiperAnimationMode_FromNumeric(ordinal: int32): SwiperAnimationMode {
+        return ordinal as SwiperAnimationMode
+    }
+    static SwiperDisplayMode_ToNumeric(value: SwiperDisplayMode): int32 {
+        return value as int32
+    }
+    static SwiperDisplayMode_FromNumeric(ordinal: int32): SwiperDisplayMode {
+        return ordinal as SwiperDisplayMode
+    }
+    static SwiperNestedScrollMode_ToNumeric(value: SwiperNestedScrollMode): int32 {
+        return value as int32
+    }
+    static SwiperNestedScrollMode_FromNumeric(ordinal: int32): SwiperNestedScrollMode {
+        return ordinal as SwiperNestedScrollMode
+    }
+    static SymbolEffectStrategy_ToNumeric(value: SymbolEffectStrategy): int32 {
+        return value as int32
+    }
+    static SymbolEffectStrategy_FromNumeric(ordinal: int32): SymbolEffectStrategy {
+        return ordinal as SymbolEffectStrategy
+    }
+    static SymbolRenderingStrategy_ToNumeric(value: SymbolRenderingStrategy): int32 {
+        return value as int32
+    }
+    static SymbolRenderingStrategy_FromNumeric(ordinal: int32): SymbolRenderingStrategy {
+        return ordinal as SymbolRenderingStrategy
+    }
+    static TabsCacheMode_ToNumeric(value: TabsCacheMode): int32 {
+        return value as int32
+    }
+    static TabsCacheMode_FromNumeric(ordinal: int32): TabsCacheMode {
+        return ordinal as TabsCacheMode
+    }
+    static text_Affinity_ToNumeric(value: text.Affinity): int32 {
+        return value as int32
+    }
+    static text_Affinity_FromNumeric(ordinal: int32): text.Affinity {
+        return ordinal as text.Affinity
+    }
+    static text_BreakStrategy_ToNumeric(value: text.BreakStrategy): int32 {
+        return value as int32
+    }
+    static text_BreakStrategy_FromNumeric(ordinal: int32): text.BreakStrategy {
+        return ordinal as text.BreakStrategy
+    }
+    static text_EllipsisMode_ToNumeric(value: text.EllipsisMode): int32 {
+        return value as int32
+    }
+    static text_EllipsisMode_FromNumeric(ordinal: int32): text.EllipsisMode {
+        return ordinal as text.EllipsisMode
+    }
+    static text_FontStyle_ToNumeric(value: text.FontStyle): int32 {
+        return value as int32
+    }
+    static text_FontStyle_FromNumeric(ordinal: int32): text.FontStyle {
+        return ordinal as text.FontStyle
+    }
+    static text_FontWeight_ToNumeric(value: text.FontWeight): int32 {
+        return value as int32
+    }
+    static text_FontWeight_FromNumeric(ordinal: int32): text.FontWeight {
+        return ordinal as text.FontWeight
+    }
+    static text_FontWidth_ToNumeric(value: text.FontWidth): int32 {
+        return value as int32
+    }
+    static text_FontWidth_FromNumeric(ordinal: int32): text.FontWidth {
+        return ordinal as text.FontWidth
+    }
+    static text_PlaceholderAlignment_ToNumeric(value: text.PlaceholderAlignment): int32 {
+        return value as int32
+    }
+    static text_PlaceholderAlignment_FromNumeric(ordinal: int32): text.PlaceholderAlignment {
+        return ordinal as text.PlaceholderAlignment
+    }
+    static text_RectHeightStyle_ToNumeric(value: text.RectHeightStyle): int32 {
+        return value as int32
+    }
+    static text_RectHeightStyle_FromNumeric(ordinal: int32): text.RectHeightStyle {
+        return ordinal as text.RectHeightStyle
+    }
+    static text_RectWidthStyle_ToNumeric(value: text.RectWidthStyle): int32 {
+        return value as int32
+    }
+    static text_RectWidthStyle_FromNumeric(ordinal: int32): text.RectWidthStyle {
+        return ordinal as text.RectWidthStyle
+    }
+    static text_SystemFontType_ToNumeric(value: text.SystemFontType): int32 {
+        return value as int32
+    }
+    static text_SystemFontType_FromNumeric(ordinal: int32): text.SystemFontType {
+        return ordinal as text.SystemFontType
+    }
+    static text_TextAlign_ToNumeric(value: text.TextAlign): int32 {
+        return value as int32
+    }
+    static text_TextAlign_FromNumeric(ordinal: int32): text.TextAlign {
+        return ordinal as text.TextAlign
+    }
+    static text_TextBaseline_ToNumeric(value: text.TextBaseline): int32 {
+        return value as int32
+    }
+    static text_TextBaseline_FromNumeric(ordinal: int32): text.TextBaseline {
+        return ordinal as text.TextBaseline
+    }
+    static text_TextDecorationStyle_ToNumeric(value: text.TextDecorationStyle): int32 {
+        return value as int32
+    }
+    static text_TextDecorationStyle_FromNumeric(ordinal: int32): text.TextDecorationStyle {
+        return ordinal as text.TextDecorationStyle
+    }
+    static text_TextDecorationType_ToNumeric(value: text.TextDecorationType): int32 {
+        return value as int32
+    }
+    static text_TextDecorationType_FromNumeric(ordinal: int32): text.TextDecorationType {
+        return ordinal as text.TextDecorationType
+    }
+    static text_TextDirection_ToNumeric(value: text.TextDirection): int32 {
+        return value as int32
+    }
+    static text_TextDirection_FromNumeric(ordinal: int32): text.TextDirection {
+        return ordinal as text.TextDirection
+    }
+    static text_TextHeightBehavior_ToNumeric(value: text.TextHeightBehavior): int32 {
+        return value as int32
+    }
+    static text_TextHeightBehavior_FromNumeric(ordinal: int32): text.TextHeightBehavior {
+        return ordinal as text.TextHeightBehavior
+    }
+    static text_WordBreak_ToNumeric(value: text.WordBreak): int32 {
+        return value as int32
+    }
+    static text_WordBreak_FromNumeric(ordinal: int32): text.WordBreak {
+        return ordinal as text.WordBreak
+    }
+    static TextAlign_ToNumeric(value: TextAlign): int32 {
+        return value as int32
+    }
+    static TextAlign_FromNumeric(ordinal: int32): TextAlign {
+        return ordinal as TextAlign
+    }
+    static TextAreaType_ToNumeric(value: TextAreaType): int32 {
+        return value as int32
+    }
+    static TextAreaType_FromNumeric(ordinal: int32): TextAreaType {
+        return ordinal as TextAreaType
+    }
+    static TextCase_ToNumeric(value: TextCase): int32 {
+        return value as int32
+    }
+    static TextCase_FromNumeric(ordinal: int32): TextCase {
+        return ordinal as TextCase
+    }
+    static TextContentStyle_ToNumeric(value: TextContentStyle): int32 {
+        return value as int32
+    }
+    static TextContentStyle_FromNumeric(ordinal: int32): TextContentStyle {
+        return ordinal as TextContentStyle
+    }
+    static TextDataDetectorType_ToNumeric(value: TextDataDetectorType): int32 {
+        return value as int32
+    }
+    static TextDataDetectorType_FromNumeric(ordinal: int32): TextDataDetectorType {
+        return ordinal as TextDataDetectorType
+    }
+    static TextDecorationStyle_ToNumeric(value: TextDecorationStyle): int32 {
+        return value as int32
+    }
+    static TextDecorationStyle_FromNumeric(ordinal: int32): TextDecorationStyle {
+        return ordinal as TextDecorationStyle
+    }
+    static TextDecorationType_ToNumeric(value: TextDecorationType): int32 {
+        return value as int32
+    }
+    static TextDecorationType_FromNumeric(ordinal: int32): TextDecorationType {
+        return ordinal as TextDecorationType
+    }
+    static TextDeleteDirection_ToNumeric(value: TextDeleteDirection): int32 {
+        return value as int32
+    }
+    static TextDeleteDirection_FromNumeric(ordinal: int32): TextDeleteDirection {
+        return ordinal as TextDeleteDirection
+    }
+    static TextHeightAdaptivePolicy_ToNumeric(value: TextHeightAdaptivePolicy): int32 {
+        return value as int32
+    }
+    static TextHeightAdaptivePolicy_FromNumeric(ordinal: int32): TextHeightAdaptivePolicy {
+        return ordinal as TextHeightAdaptivePolicy
+    }
+    static TextInputStyle_ToNumeric(value: TextInputStyle): int32 {
+        return value as int32
+    }
+    static TextInputStyle_FromNumeric(ordinal: int32): TextInputStyle {
+        return ordinal as TextInputStyle
+    }
+    static TextMenuShowMode_ToNumeric(value: TextMenuShowMode): int32 {
+        return value as int32
+    }
+    static TextMenuShowMode_FromNumeric(ordinal: int32): TextMenuShowMode {
+        return ordinal as TextMenuShowMode
+    }
+    static TextOverflow_ToNumeric(value: TextOverflow): int32 {
+        return value as int32
+    }
+    static TextOverflow_FromNumeric(ordinal: int32): TextOverflow {
+        return ordinal as TextOverflow
+    }
+    static TextResponseType_ToNumeric(value: TextResponseType): int32 {
+        return value as int32
+    }
+    static TextResponseType_FromNumeric(ordinal: int32): TextResponseType {
+        return ordinal as TextResponseType
+    }
+    static TextSelectableMode_ToNumeric(value: TextSelectableMode): int32 {
+        return value as int32
+    }
+    static TextSelectableMode_FromNumeric(ordinal: int32): TextSelectableMode {
+        return ordinal as TextSelectableMode
+    }
+    static TextSpanType_ToNumeric(value: TextSpanType): int32 {
+        return value as int32
+    }
+    static TextSpanType_FromNumeric(ordinal: int32): TextSpanType {
+        return ordinal as TextSpanType
+    }
+    static ThemeColorMode_ToNumeric(value: ThemeColorMode): int32 {
+        return value as int32
+    }
+    static ThemeColorMode_FromNumeric(ordinal: int32): ThemeColorMode {
+        return ordinal as ThemeColorMode
+    }
+    static ThreatType_ToNumeric(value: ThreatType): int32 {
+        return value as int32
+    }
+    static ThreatType_FromNumeric(ordinal: int32): ThreatType {
+        return ordinal as ThreatType
+    }
+    static TimePickerFormat_ToNumeric(value: TimePickerFormat): int32 {
+        return value as int32
+    }
+    static TimePickerFormat_FromNumeric(ordinal: int32): TimePickerFormat {
+        return ordinal as TimePickerFormat
+    }
+    static TitleHeight_ToNumeric(value: TitleHeight): int32 {
+        return value as int32
+    }
+    static TitleHeight_FromNumeric(ordinal: int32): TitleHeight {
+        return ordinal as TitleHeight
+    }
+    static ToggleType_ToNumeric(value: ToggleType): int32 {
+        return value as int32
+    }
+    static ToggleType_FromNumeric(ordinal: int32): ToggleType {
+        return ordinal as ToggleType
+    }
+    static ToolbarItemStatus_ToNumeric(value: ToolbarItemStatus): int32 {
+        return value as int32
+    }
+    static ToolbarItemStatus_FromNumeric(ordinal: int32): ToolbarItemStatus {
+        return ordinal as ToolbarItemStatus
+    }
+    static TouchTestStrategy_ToNumeric(value: TouchTestStrategy): int32 {
+        return value as int32
+    }
+    static TouchTestStrategy_FromNumeric(ordinal: int32): TouchTestStrategy {
+        return ordinal as TouchTestStrategy
+    }
+    static TouchType_ToNumeric(value: TouchType): int32 {
+        return value as int32
+    }
+    static TouchType_FromNumeric(ordinal: int32): TouchType {
+        return ordinal as TouchType
+    }
+    static TransitionEdge_ToNumeric(value: TransitionEdge): int32 {
+        return value as int32
+    }
+    static TransitionEdge_FromNumeric(ordinal: int32): TransitionEdge {
+        return ordinal as TransitionEdge
+    }
+    static TransitionHierarchyStrategy_ToNumeric(value: TransitionHierarchyStrategy): int32 {
+        return value as int32
+    }
+    static TransitionHierarchyStrategy_FromNumeric(ordinal: int32): TransitionHierarchyStrategy {
+        return ordinal as TransitionHierarchyStrategy
+    }
+    static TransitionType_ToNumeric(value: TransitionType): int32 {
+        return value as int32
+    }
+    static TransitionType_FromNumeric(ordinal: int32): TransitionType {
+        return ordinal as TransitionType
+    }
+    static uniformTypeDescriptor_UniformDataType_ToNumeric(value: uniformTypeDescriptor.UniformDataType): int32 {
+        return value as int32
+    }
+    static uniformTypeDescriptor_UniformDataType_FromNumeric(ordinal: int32): uniformTypeDescriptor.UniformDataType {
+        return ordinal as uniformTypeDescriptor.UniformDataType
+    }
+    static VerticalAlign_ToNumeric(value: VerticalAlign): int32 {
+        return value as int32
+    }
+    static VerticalAlign_FromNumeric(ordinal: int32): VerticalAlign {
+        return ordinal as VerticalAlign
+    }
+    static ViewportFit_ToNumeric(value: ViewportFit): int32 {
+        return value as int32
+    }
+    static ViewportFit_FromNumeric(ordinal: int32): ViewportFit {
+        return ordinal as ViewportFit
+    }
+    static Visibility_ToNumeric(value: Visibility): int32 {
+        return value as int32
+    }
+    static Visibility_FromNumeric(ordinal: int32): Visibility {
+        return ordinal as Visibility
+    }
+    static WaterFlowLayoutMode_ToNumeric(value: WaterFlowLayoutMode): int32 {
+        return value as int32
+    }
+    static WaterFlowLayoutMode_FromNumeric(ordinal: int32): WaterFlowLayoutMode {
+        return ordinal as WaterFlowLayoutMode
+    }
+    static WebCaptureMode_ToNumeric(value: WebCaptureMode): int32 {
+        return value as int32
+    }
+    static WebCaptureMode_FromNumeric(ordinal: int32): WebCaptureMode {
+        return ordinal as WebCaptureMode
+    }
+    static WebDarkMode_ToNumeric(value: WebDarkMode): int32 {
+        return value as int32
+    }
+    static WebDarkMode_FromNumeric(ordinal: int32): WebDarkMode {
+        return ordinal as WebDarkMode
+    }
+    static WebElementType_ToNumeric(value: WebElementType): int32 {
+        return value as int32
+    }
+    static WebElementType_FromNumeric(ordinal: int32): WebElementType {
+        return ordinal as WebElementType
+    }
+    static WebKeyboardAvoidMode_ToNumeric(value: WebKeyboardAvoidMode): int32 {
+        return value as int32
+    }
+    static WebKeyboardAvoidMode_FromNumeric(ordinal: int32): WebKeyboardAvoidMode {
+        return ordinal as WebKeyboardAvoidMode
+    }
+    static WebLayoutMode_ToNumeric(value: WebLayoutMode): int32 {
+        return value as int32
+    }
+    static WebLayoutMode_FromNumeric(ordinal: int32): WebLayoutMode {
+        return ordinal as WebLayoutMode
+    }
+    static WebNavigationType_ToNumeric(value: WebNavigationType): int32 {
+        return value as int32
+    }
+    static WebNavigationType_FromNumeric(ordinal: int32): WebNavigationType {
+        return ordinal as WebNavigationType
+    }
+    static WebResponseType_ToNumeric(value: WebResponseType): int32 {
+        return value as int32
+    }
+    static WebResponseType_FromNumeric(ordinal: int32): WebResponseType {
+        return ordinal as WebResponseType
+    }
+    static Week_ToNumeric(value: Week): int32 {
+        return value as int32
+    }
+    static Week_FromNumeric(ordinal: int32): Week {
+        return ordinal as Week
+    }
+    static WidthBreakpoint_ToNumeric(value: WidthBreakpoint): int32 {
+        return value as int32
+    }
+    static WidthBreakpoint_FromNumeric(ordinal: int32): WidthBreakpoint {
+        return ordinal as WidthBreakpoint
+    }
+    static window_WindowStatusType_ToNumeric(value: window.WindowStatusType): int32 {
+        return value as int32
+    }
+    static window_WindowStatusType_FromNumeric(ordinal: int32): window.WindowStatusType {
+        return ordinal as window.WindowStatusType
+    }
+    static WindowModeFollowStrategy_ToNumeric(value: WindowModeFollowStrategy): int32 {
+        return value as int32
+    }
+    static WindowModeFollowStrategy_FromNumeric(ordinal: int32): WindowModeFollowStrategy {
+        return ordinal as WindowModeFollowStrategy
+    }
+    static WordBreak_ToNumeric(value: WordBreak): int32 {
+        return value as int32
+    }
+    static WordBreak_FromNumeric(ordinal: int32): WordBreak {
+        return ordinal as WordBreak
+    }
+    static XComponentType_ToNumeric(value: XComponentType): int32 {
+        return value as int32
+    }
+    static XComponentType_FromNumeric(ordinal: int32): XComponentType {
+        return ordinal as XComponentType
+    }
+    static isArray_Number(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_common2D_Point(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_common2D_Rect(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_drawing_RectType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_CustomObject(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_drawing_TextBlobRunBuffer(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_String(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SourceTool(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_GestureType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ImageAnalyzerType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Layoutable(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Measurable(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ColorStop(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Opt_Object(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_NavPathInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Union_Number_String(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Union_RichEditorImageSpanResult_RichEditorTextSpanResult(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_RichEditorParagraphResult(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_RichEditorSpan(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_StyleOptions(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SpanStyle(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_TextBox(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_TextLine(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_LineMetrics(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_Run(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SectionOptions(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Header(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_webview_WebHeader(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TextMenuItem(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TouchTestInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_NavDestinationTransition(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ResourceStr(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_GestureRecognizer(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_font_UIFontGenericInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_font_UIFontFallbackGroupInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_font_UIFontFallbackInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_font_UIFontAliasInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_font_UIFontAdjustInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_FractionStop(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Tuple_ResourceColor_Number(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_CalendarDay(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Buffer(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Object(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Union_RichEditorTextSpanResult_RichEditorImageSpanResult(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ShadowOptions(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_DateRange(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Union_ResourceColor_LinearGradient(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_DragPreviewMode(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_RichEditorTextSpanResult(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_RichEditorImageSpanResult(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ResourceColor(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TextCascadePickerRangeContent(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Array_String(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TextPickerRangeContent(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_LengthMetrics(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_RadiusItem(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Dimension(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_FontFeature(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_TextShadow(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_FontVariation(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TextDataDetectorType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_FingerInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_MouseButton(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_TouchObject(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_HistoricalPoint(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_text_FontDescriptor(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SheetInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_AlertDialogButtonOptions(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Rectangle(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_uniformTypeDescriptor_UniformDataType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ObscuredReasons(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SafeAreaType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_SafeAreaEdge(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_MenuElement(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ModifierKey(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Length(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Tuple_Union_ResourceColor_LinearGradient_Number(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ImageFrameInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_NavigationMenuItem(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_Scroller(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_NestedScrollInfo(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ToolbarItem(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_LayoutSafeAreaType(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_LayoutSafeAreaEdge(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ParticlePropertyAnimation(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ShapePoint(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_GuideLineStyle(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_BarrierStyle(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+    static isArray_ScriptItem(value: Object | string | number | undefined): boolean {
+        return Array.isArray(value)
+    }
+}
diff --git a/arkoala-arkts/framework/native/src/generated/Serializers.h b/arkoala-arkts/framework/native/src/generated/Serializers.h
index 664cfc6b48..68a27afe54 100644
--- a/arkoala-arkts/framework/native/src/generated/Serializers.h
+++ b/arkoala-arkts/framework/native/src/generated/Serializers.h
@@ -1248,6 +1248,33 @@ inline Ark_RuntimeType runtimeType(const Opt_CalendarAlign& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_CalendarController& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CalendarController value) {
+    WriteToString(result, static_cast<InteropNativePointer>(value));
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CalendarController* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CalendarController& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CalendarPickerDialog& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -15858,6 +15885,33 @@ inline Ark_RuntimeType runtimeType(const Opt_TransitionEdge& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_TransitionEffect& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_TransitionEffect value) {
+    WriteToString(result, static_cast<InteropNativePointer>(value));
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_TransitionEffect* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_TransitionEffect& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_TransitionHierarchyStrategy& value)
 {
     return INTEROP_RUNTIME_NUMBER;
@@ -18600,6 +18654,46 @@ inline Ark_RuntimeType runtimeType(const Opt_Array_Buffer& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Array_CalendarDay& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+
+template <>
+void WriteToString(std::string* result, const Ark_CalendarDay* value);
+
+template <>
+inline void WriteToString(std::string* result, const Array_CalendarDay* value) {
+    int32_t count = value->length;
+    result->append("{.array=allocArray<Ark_CalendarDay, " + std::to_string(count) + ">({{");
+    for (int i = 0; i < count; i++) {
+        if (i > 0) result->append(", ");
+        WriteToString(result, const_cast<const Ark_CalendarDay*>(&value->array[i]));
+    }
+    result->append("}})");
+    result->append(", .length=");
+    result->append(std::to_string(value->length));
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_Array_CalendarDay* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_Array_CalendarDay& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Array_ColorStop& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -22323,6 +22417,68 @@ inline Ark_RuntimeType runtimeType(const Opt_Callback_Buffer_Void& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Callback_CalendarRequestedData_Void& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Callback_CalendarRequestedData_Void* value) {
+    result->append("{");
+    result->append(".resource=");
+    WriteToString(result, &value->resource);
+    result->append(", .call=0");
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_Callback_CalendarRequestedData_Void* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_Callback_CalendarRequestedData_Void& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Callback_CalendarSelectedDate_Void& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Callback_CalendarSelectedDate_Void* value) {
+    result->append("{");
+    result->append(".resource=");
+    WriteToString(result, &value->resource);
+    result->append(", .call=0");
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_Callback_CalendarSelectedDate_Void* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_Callback_CalendarSelectedDate_Void& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Callback_ClickEvent_LocationButtonOnClickResult_Void& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -31683,6 +31839,41 @@ inline Ark_RuntimeType runtimeType(const Opt_ASTCResource& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_AsymmetricTransitionOption& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_AsymmetricTransitionOption* value) {
+    result->append("{");
+    // Ark_TransitionEffect appear
+    result->append(".appear=");
+    WriteToString(result, value->appear);
+    // Ark_TransitionEffect disappear
+    result->append(", ");
+    result->append(".disappear=");
+    WriteToString(result, value->disappear);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_AsymmetricTransitionOption* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_AsymmetricTransitionOption& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_AutoPlayOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -32228,6 +32419,163 @@ inline Ark_RuntimeType runtimeType(const Opt_ButtonOptions& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_CalendarDay& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CalendarDay* value) {
+    result->append("{");
+    // Ark_Number index
+    result->append(".index=");
+    WriteToString(result, &value->index);
+    // Ark_String lunarMonth
+    result->append(", ");
+    result->append(".lunarMonth=");
+    WriteToString(result, &value->lunarMonth);
+    // Ark_String lunarDay
+    result->append(", ");
+    result->append(".lunarDay=");
+    WriteToString(result, &value->lunarDay);
+    // Ark_String dayMark
+    result->append(", ");
+    result->append(".dayMark=");
+    WriteToString(result, &value->dayMark);
+    // Ark_String dayMarkValue
+    result->append(", ");
+    result->append(".dayMarkValue=");
+    WriteToString(result, &value->dayMarkValue);
+    // Ark_Number year
+    result->append(", ");
+    result->append(".year=");
+    WriteToString(result, &value->year);
+    // Ark_Number month
+    result->append(", ");
+    result->append(".month=");
+    WriteToString(result, &value->month);
+    // Ark_Number day
+    result->append(", ");
+    result->append(".day=");
+    WriteToString(result, &value->day);
+    // Ark_Boolean isFirstOfLunar
+    result->append(", ");
+    result->append(".isFirstOfLunar=");
+    WriteToString(result, value->isFirstOfLunar);
+    // Ark_Boolean hasSchedule
+    result->append(", ");
+    result->append(".hasSchedule=");
+    WriteToString(result, value->hasSchedule);
+    // Ark_Boolean markLunarDay
+    result->append(", ");
+    result->append(".markLunarDay=");
+    WriteToString(result, value->markLunarDay);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CalendarDay* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CalendarDay& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Ark_CalendarRequestedData& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CalendarRequestedData* value) {
+    result->append("{");
+    // Ark_Number year
+    result->append(".year=");
+    WriteToString(result, &value->year);
+    // Ark_Number month
+    result->append(", ");
+    result->append(".month=");
+    WriteToString(result, &value->month);
+    // Ark_Number currentYear
+    result->append(", ");
+    result->append(".currentYear=");
+    WriteToString(result, &value->currentYear);
+    // Ark_Number currentMonth
+    result->append(", ");
+    result->append(".currentMonth=");
+    WriteToString(result, &value->currentMonth);
+    // Ark_Number monthState
+    result->append(", ");
+    result->append(".monthState=");
+    WriteToString(result, &value->monthState);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CalendarRequestedData* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CalendarRequestedData& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Ark_CalendarSelectedDate& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CalendarSelectedDate* value) {
+    result->append("{");
+    // Ark_Number year
+    result->append(".year=");
+    WriteToString(result, &value->year);
+    // Ark_Number month
+    result->append(", ");
+    result->append(".month=");
+    WriteToString(result, &value->month);
+    // Ark_Number day
+    result->append(", ");
+    result->append(".day=");
+    WriteToString(result, &value->day);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CalendarSelectedDate* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CalendarSelectedDate& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CancelButtonSymbolOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -37282,6 +37630,45 @@ inline Ark_RuntimeType runtimeType(const Opt_MessageEvents& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_MonthData& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_MonthData* value) {
+    result->append("{");
+    // Ark_Number year
+    result->append(".year=");
+    WriteToString(result, &value->year);
+    // Ark_Number month
+    result->append(", ");
+    result->append(".month=");
+    WriteToString(result, &value->month);
+    // Array_CalendarDay data
+    result->append(", ");
+    result->append(".data=");
+    WriteToString(result, &value->data);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_MonthData* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_MonthData& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_MotionBlurAnchor& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -46674,6 +47061,53 @@ inline Ark_RuntimeType runtimeType(const Opt_CalendarOptions& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_CalendarRequestedMonths& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CalendarRequestedMonths* value) {
+    result->append("{");
+    // Ark_CalendarSelectedDate date
+    result->append(".date=");
+    WriteToString(result, &value->date);
+    // Ark_MonthData currentData
+    result->append(", ");
+    result->append(".currentData=");
+    WriteToString(result, &value->currentData);
+    // Ark_MonthData preData
+    result->append(", ");
+    result->append(".preData=");
+    WriteToString(result, &value->preData);
+    // Ark_MonthData nextData
+    result->append(", ");
+    result->append(".nextData=");
+    WriteToString(result, &value->nextData);
+    // Ark_CalendarController controller
+    result->append(", ");
+    result->append(".controller=");
+    WriteToString(result, &value->controller);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CalendarRequestedMonths* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CalendarRequestedMonths& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CanvasRenderer& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -47061,6 +47495,104 @@ inline Ark_RuntimeType runtimeType(const Opt_ComponentInfo& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_ContentCoverOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_ContentCoverOptions* value) {
+    result->append("{");
+    // Ark_ResourceColor backgroundColor
+    result->append(".backgroundColor=");
+    WriteToString(result, &value->backgroundColor);
+    // Callback_Void onAppear
+    result->append(", ");
+    result->append(".onAppear=");
+    WriteToString(result, &value->onAppear);
+    // Callback_Void onDisappear
+    result->append(", ");
+    result->append(".onDisappear=");
+    WriteToString(result, &value->onDisappear);
+    // Callback_Void onWillAppear
+    result->append(", ");
+    result->append(".onWillAppear=");
+    WriteToString(result, &value->onWillAppear);
+    // Callback_Void onWillDisappear
+    result->append(", ");
+    result->append(".onWillDisappear=");
+    WriteToString(result, &value->onWillDisappear);
+    // Ark_ModalTransition modalTransition
+    result->append(", ");
+    result->append(".modalTransition=");
+    WriteToString(result, &value->modalTransition);
+    // Callback_DismissContentCoverAction_Void onWillDismiss
+    result->append(", ");
+    result->append(".onWillDismiss=");
+    WriteToString(result, &value->onWillDismiss);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_ContentCoverOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_ContentCoverOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Ark_ContextMenuAnimationOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_ContextMenuAnimationOptions* value) {
+    result->append("{");
+    // Ark_AnimationNumberRange scale
+    result->append(".scale=");
+    WriteToString(result, &value->scale);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_AnimationNumberRange hoverScale
+    result->append(", ");
+    result->append(".hoverScale=");
+    WriteToString(result, &value->hoverScale);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_ContextMenuAnimationOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_ContextMenuAnimationOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CopyEvent& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -47092,6 +47624,125 @@ inline Ark_RuntimeType runtimeType(const Opt_CopyEvent& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_CurrentDayStyle& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CurrentDayStyle* value) {
+    result->append("{");
+    // Ark_ResourceColor dayColor
+    result->append(".dayColor=");
+    WriteToString(result, &value->dayColor);
+    // Ark_ResourceColor lunarColor
+    result->append(", ");
+    result->append(".lunarColor=");
+    WriteToString(result, &value->lunarColor);
+    // Ark_ResourceColor markLunarColor
+    result->append(", ");
+    result->append(".markLunarColor=");
+    WriteToString(result, &value->markLunarColor);
+    // Ark_Number dayFontSize
+    result->append(", ");
+    result->append(".dayFontSize=");
+    WriteToString(result, &value->dayFontSize);
+    // Ark_Number lunarDayFontSize
+    result->append(", ");
+    result->append(".lunarDayFontSize=");
+    WriteToString(result, &value->lunarDayFontSize);
+    // Ark_Number dayHeight
+    result->append(", ");
+    result->append(".dayHeight=");
+    WriteToString(result, &value->dayHeight);
+    // Ark_Number dayWidth
+    result->append(", ");
+    result->append(".dayWidth=");
+    WriteToString(result, &value->dayWidth);
+    // Ark_Number gregorianCalendarHeight
+    result->append(", ");
+    result->append(".gregorianCalendarHeight=");
+    WriteToString(result, &value->gregorianCalendarHeight);
+    // Ark_Number dayYAxisOffset
+    result->append(", ");
+    result->append(".dayYAxisOffset=");
+    WriteToString(result, &value->dayYAxisOffset);
+    // Ark_Number lunarDayYAxisOffset
+    result->append(", ");
+    result->append(".lunarDayYAxisOffset=");
+    WriteToString(result, &value->lunarDayYAxisOffset);
+    // Ark_Number underscoreXAxisOffset
+    result->append(", ");
+    result->append(".underscoreXAxisOffset=");
+    WriteToString(result, &value->underscoreXAxisOffset);
+    // Ark_Number underscoreYAxisOffset
+    result->append(", ");
+    result->append(".underscoreYAxisOffset=");
+    WriteToString(result, &value->underscoreYAxisOffset);
+    // Ark_Number scheduleMarkerXAxisOffset
+    result->append(", ");
+    result->append(".scheduleMarkerXAxisOffset=");
+    WriteToString(result, &value->scheduleMarkerXAxisOffset);
+    // Ark_Number scheduleMarkerYAxisOffset
+    result->append(", ");
+    result->append(".scheduleMarkerYAxisOffset=");
+    WriteToString(result, &value->scheduleMarkerYAxisOffset);
+    // Ark_Number colSpace
+    result->append(", ");
+    result->append(".colSpace=");
+    WriteToString(result, &value->colSpace);
+    // Ark_Number dailyFiveRowSpace
+    result->append(", ");
+    result->append(".dailyFiveRowSpace=");
+    WriteToString(result, &value->dailyFiveRowSpace);
+    // Ark_Number dailySixRowSpace
+    result->append(", ");
+    result->append(".dailySixRowSpace=");
+    WriteToString(result, &value->dailySixRowSpace);
+    // Ark_Number lunarHeight
+    result->append(", ");
+    result->append(".lunarHeight=");
+    WriteToString(result, &value->lunarHeight);
+    // Ark_Number underscoreWidth
+    result->append(", ");
+    result->append(".underscoreWidth=");
+    WriteToString(result, &value->underscoreWidth);
+    // Ark_Number underscoreLength
+    result->append(", ");
+    result->append(".underscoreLength=");
+    WriteToString(result, &value->underscoreLength);
+    // Ark_Number scheduleMarkerRadius
+    result->append(", ");
+    result->append(".scheduleMarkerRadius=");
+    WriteToString(result, &value->scheduleMarkerRadius);
+    // Ark_Number boundaryRowOffset
+    result->append(", ");
+    result->append(".boundaryRowOffset=");
+    WriteToString(result, &value->boundaryRowOffset);
+    // Ark_Number boundaryColOffset
+    result->append(", ");
+    result->append(".boundaryColOffset=");
+    WriteToString(result, &value->boundaryColOffset);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CurrentDayStyle* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CurrentDayStyle& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CutEvent& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -48913,6 +49564,49 @@ inline Ark_RuntimeType runtimeType(const Opt_NavigationTransitionProxy& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_NonCurrentDayStyle& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_NonCurrentDayStyle* value) {
+    result->append("{");
+    // Ark_ResourceColor nonCurrentMonthDayColor
+    result->append(".nonCurrentMonthDayColor=");
+    WriteToString(result, &value->nonCurrentMonthDayColor);
+    // Ark_ResourceColor nonCurrentMonthLunarColor
+    result->append(", ");
+    result->append(".nonCurrentMonthLunarColor=");
+    WriteToString(result, &value->nonCurrentMonthLunarColor);
+    // Ark_ResourceColor nonCurrentMonthWorkDayMarkColor
+    result->append(", ");
+    result->append(".nonCurrentMonthWorkDayMarkColor=");
+    WriteToString(result, &value->nonCurrentMonthWorkDayMarkColor);
+    // Ark_ResourceColor nonCurrentMonthOffDayMarkColor
+    result->append(", ");
+    result->append(".nonCurrentMonthOffDayMarkColor=");
+    WriteToString(result, &value->nonCurrentMonthOffDayMarkColor);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_NonCurrentDayStyle* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_NonCurrentDayStyle& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_OffscreenCanvasRenderingContext2D& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -50659,6 +51353,49 @@ inline Ark_RuntimeType runtimeType(const Opt_TextStyleInterface& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_TodayStyle& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_TodayStyle* value) {
+    result->append("{");
+    // Ark_ResourceColor focusedDayColor
+    result->append(".focusedDayColor=");
+    WriteToString(result, &value->focusedDayColor);
+    // Ark_ResourceColor focusedLunarColor
+    result->append(", ");
+    result->append(".focusedLunarColor=");
+    WriteToString(result, &value->focusedLunarColor);
+    // Ark_ResourceColor focusedAreaBackgroundColor
+    result->append(", ");
+    result->append(".focusedAreaBackgroundColor=");
+    WriteToString(result, &value->focusedAreaBackgroundColor);
+    // Ark_Number focusedAreaRadius
+    result->append(", ");
+    result->append(".focusedAreaRadius=");
+    WriteToString(result, &value->focusedAreaRadius);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_TodayStyle* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_TodayStyle& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_ToolbarItem& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -51825,6 +52562,116 @@ inline Ark_RuntimeType runtimeType(const Opt_VideoOptions& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_WeekStyle& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_WeekStyle* value) {
+    result->append("{");
+    // Ark_ResourceColor weekColor
+    result->append(".weekColor=");
+    WriteToString(result, &value->weekColor);
+    // Ark_ResourceColor weekendDayColor
+    result->append(", ");
+    result->append(".weekendDayColor=");
+    WriteToString(result, &value->weekendDayColor);
+    // Ark_ResourceColor weekendLunarColor
+    result->append(", ");
+    result->append(".weekendLunarColor=");
+    WriteToString(result, &value->weekendLunarColor);
+    // Ark_Number weekFontSize
+    result->append(", ");
+    result->append(".weekFontSize=");
+    WriteToString(result, &value->weekFontSize);
+    // Ark_Number weekHeight
+    result->append(", ");
+    result->append(".weekHeight=");
+    WriteToString(result, &value->weekHeight);
+    // Ark_Number weekWidth
+    result->append(", ");
+    result->append(".weekWidth=");
+    WriteToString(result, &value->weekWidth);
+    // Ark_Number weekAndDayRowSpace
+    result->append(", ");
+    result->append(".weekAndDayRowSpace=");
+    WriteToString(result, &value->weekAndDayRowSpace);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_WeekStyle* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_WeekStyle& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Ark_WorkStateStyle& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_WorkStateStyle* value) {
+    result->append("{");
+    // Ark_ResourceColor workDayMarkColor
+    result->append(".workDayMarkColor=");
+    WriteToString(result, &value->workDayMarkColor);
+    // Ark_ResourceColor offDayMarkColor
+    result->append(", ");
+    result->append(".offDayMarkColor=");
+    WriteToString(result, &value->offDayMarkColor);
+    // Ark_Number workDayMarkSize
+    result->append(", ");
+    result->append(".workDayMarkSize=");
+    WriteToString(result, &value->workDayMarkSize);
+    // Ark_Number offDayMarkSize
+    result->append(", ");
+    result->append(".offDayMarkSize=");
+    WriteToString(result, &value->offDayMarkSize);
+    // Ark_Number workStateWidth
+    result->append(", ");
+    result->append(".workStateWidth=");
+    WriteToString(result, &value->workStateWidth);
+    // Ark_Number workStateHorizontalMovingDistance
+    result->append(", ");
+    result->append(".workStateHorizontalMovingDistance=");
+    WriteToString(result, &value->workStateHorizontalMovingDistance);
+    // Ark_Number workStateVerticalMovingDistance
+    result->append(", ");
+    result->append(".workStateVerticalMovingDistance=");
+    WriteToString(result, &value->workStateVerticalMovingDistance);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_WorkStateStyle* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_WorkStateStyle& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_XComponentOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -56858,6 +57705,121 @@ inline Ark_RuntimeType runtimeType(const Opt_CapsuleStyleOptions& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_ContextMenuOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_ContextMenuOptions* value) {
+    result->append("{");
+    // Ark_Position offset
+    result->append(".offset=");
+    WriteToString(result, &value->offset);
+    // Ark_Placement placement
+    result->append(", ");
+    result->append(".placement=");
+    WriteToString(result, &value->placement);
+    // Ark_Boolean enableArrow
+    result->append(", ");
+    result->append(".enableArrow=");
+    WriteToString(result, &value->enableArrow);
+    // Ark_Length arrowOffset
+    result->append(", ");
+    result->append(".arrowOffset=");
+    WriteToString(result, &value->arrowOffset);
+    // Ark_Union_MenuPreviewMode_CustomBuilder preview
+    result->append(", ");
+    result->append(".preview=");
+    WriteToString(result, &value->preview);
+    // Ark_BorderRadiusType previewBorderRadius
+    result->append(", ");
+    result->append(".previewBorderRadius=");
+    WriteToString(result, &value->previewBorderRadius);
+    // Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius
+    result->append(", ");
+    result->append(".borderRadius=");
+    WriteToString(result, &value->borderRadius);
+    // Callback_Void onAppear
+    result->append(", ");
+    result->append(".onAppear=");
+    WriteToString(result, &value->onAppear);
+    // Callback_Void onDisappear
+    result->append(", ");
+    result->append(".onDisappear=");
+    WriteToString(result, &value->onDisappear);
+    // Callback_Void aboutToAppear
+    result->append(", ");
+    result->append(".aboutToAppear=");
+    WriteToString(result, &value->aboutToAppear);
+    // Callback_Void aboutToDisappear
+    result->append(", ");
+    result->append(".aboutToDisappear=");
+    WriteToString(result, &value->aboutToDisappear);
+    // Ark_Padding layoutRegionMargin
+    result->append(", ");
+    result->append(".layoutRegionMargin=");
+    WriteToString(result, &value->layoutRegionMargin);
+    // Ark_ContextMenuAnimationOptions previewAnimationOptions
+    result->append(", ");
+    result->append(".previewAnimationOptions=");
+    WriteToString(result, &value->previewAnimationOptions);
+    // Ark_ResourceColor backgroundColor
+    result->append(", ");
+    result->append(".backgroundColor=");
+    WriteToString(result, &value->backgroundColor);
+    // Ark_BlurStyle backgroundBlurStyle
+    result->append(", ");
+    result->append(".backgroundBlurStyle=");
+    WriteToString(result, &value->backgroundBlurStyle);
+    // Ark_BackgroundBlurStyleOptions backgroundBlurStyleOptions
+    result->append(", ");
+    result->append(".backgroundBlurStyleOptions=");
+    WriteToString(result, &value->backgroundBlurStyleOptions);
+    // Ark_BackgroundEffectOptions backgroundEffect
+    result->append(", ");
+    result->append(".backgroundEffect=");
+    WriteToString(result, &value->backgroundEffect);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_Boolean enableHoverMode
+    result->append(", ");
+    result->append(".enableHoverMode=");
+    WriteToString(result, &value->enableHoverMode);
+    // Ark_Union_ResourceColor_EdgeColors outlineColor
+    result->append(", ");
+    result->append(".outlineColor=");
+    WriteToString(result, &value->outlineColor);
+    // Ark_Union_Dimension_EdgeOutlineWidths outlineWidth
+    result->append(", ");
+    result->append(".outlineWidth=");
+    WriteToString(result, &value->outlineWidth);
+    // Ark_HapticFeedbackMode hapticFeedbackMode
+    result->append(", ");
+    result->append(".hapticFeedbackMode=");
+    WriteToString(result, &value->hapticFeedbackMode);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_ContextMenuOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_ContextMenuOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_CustomDialogControllerOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -57037,6 +57999,129 @@ inline Ark_RuntimeType runtimeType(const Opt_CustomDialogControllerOptions& valu
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_CustomPopupOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_CustomPopupOptions* value) {
+    result->append("{");
+    // CustomNodeBuilder builder
+    result->append(".builder=");
+    WriteToString(result, &value->builder);
+    // Ark_Placement placement
+    result->append(", ");
+    result->append(".placement=");
+    WriteToString(result, &value->placement);
+    // Ark_Union_Color_String_Resource_Number popupColor
+    result->append(", ");
+    result->append(".popupColor=");
+    WriteToString(result, &value->popupColor);
+    // Ark_Boolean enableArrow
+    result->append(", ");
+    result->append(".enableArrow=");
+    WriteToString(result, &value->enableArrow);
+    // Ark_Boolean autoCancel
+    result->append(", ");
+    result->append(".autoCancel=");
+    WriteToString(result, &value->autoCancel);
+    // PopupStateChangeCallback onStateChange
+    result->append(", ");
+    result->append(".onStateChange=");
+    WriteToString(result, &value->onStateChange);
+    // Ark_Length arrowOffset
+    result->append(", ");
+    result->append(".arrowOffset=");
+    WriteToString(result, &value->arrowOffset);
+    // Ark_Boolean showInSubWindow
+    result->append(", ");
+    result->append(".showInSubWindow=");
+    WriteToString(result, &value->showInSubWindow);
+    // Ark_Union_Boolean_PopupMaskType mask
+    result->append(", ");
+    result->append(".mask=");
+    WriteToString(result, &value->mask);
+    // Ark_Length targetSpace
+    result->append(", ");
+    result->append(".targetSpace=");
+    WriteToString(result, &value->targetSpace);
+    // Ark_Position offset
+    result->append(", ");
+    result->append(".offset=");
+    WriteToString(result, &value->offset);
+    // Ark_Dimension width
+    result->append(", ");
+    result->append(".width=");
+    WriteToString(result, &value->width);
+    // Ark_ArrowPointPosition arrowPointPosition
+    result->append(", ");
+    result->append(".arrowPointPosition=");
+    WriteToString(result, &value->arrowPointPosition);
+    // Ark_Dimension arrowWidth
+    result->append(", ");
+    result->append(".arrowWidth=");
+    WriteToString(result, &value->arrowWidth);
+    // Ark_Dimension arrowHeight
+    result->append(", ");
+    result->append(".arrowHeight=");
+    WriteToString(result, &value->arrowHeight);
+    // Ark_Dimension radius
+    result->append(", ");
+    result->append(".radius=");
+    WriteToString(result, &value->radius);
+    // Ark_Union_ShadowOptions_ShadowStyle shadow
+    result->append(", ");
+    result->append(".shadow=");
+    WriteToString(result, &value->shadow);
+    // Ark_BlurStyle backgroundBlurStyle
+    result->append(", ");
+    result->append(".backgroundBlurStyle=");
+    WriteToString(result, &value->backgroundBlurStyle);
+    // Ark_Boolean focusable
+    result->append(", ");
+    result->append(".focusable=");
+    WriteToString(result, &value->focusable);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
+    result->append(", ");
+    result->append(".onWillDismiss=");
+    WriteToString(result, &value->onWillDismiss);
+    // Ark_Boolean enableHoverMode
+    result->append(", ");
+    result->append(".enableHoverMode=");
+    WriteToString(result, &value->enableHoverMode);
+    // Ark_Boolean followTransformOfTarget
+    result->append(", ");
+    result->append(".followTransformOfTarget=");
+    WriteToString(result, &value->followTransformOfTarget);
+    // Ark_KeyboardAvoidMode keyboardAvoidMode
+    result->append(", ");
+    result->append(".keyboardAvoidMode=");
+    WriteToString(result, &value->keyboardAvoidMode);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_CustomPopupOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_CustomPopupOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_DigitIndicator& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -57395,6 +58480,129 @@ inline Ark_RuntimeType runtimeType(const Opt_LongPressGestureEvent& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_MenuOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_MenuOptions* value) {
+    result->append("{");
+    // Ark_Position offset
+    result->append(".offset=");
+    WriteToString(result, &value->offset);
+    // Ark_Placement placement
+    result->append(", ");
+    result->append(".placement=");
+    WriteToString(result, &value->placement);
+    // Ark_Boolean enableArrow
+    result->append(", ");
+    result->append(".enableArrow=");
+    WriteToString(result, &value->enableArrow);
+    // Ark_Length arrowOffset
+    result->append(", ");
+    result->append(".arrowOffset=");
+    WriteToString(result, &value->arrowOffset);
+    // Ark_Union_MenuPreviewMode_CustomBuilder preview
+    result->append(", ");
+    result->append(".preview=");
+    WriteToString(result, &value->preview);
+    // Ark_BorderRadiusType previewBorderRadius
+    result->append(", ");
+    result->append(".previewBorderRadius=");
+    WriteToString(result, &value->previewBorderRadius);
+    // Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius
+    result->append(", ");
+    result->append(".borderRadius=");
+    WriteToString(result, &value->borderRadius);
+    // Callback_Void onAppear
+    result->append(", ");
+    result->append(".onAppear=");
+    WriteToString(result, &value->onAppear);
+    // Callback_Void onDisappear
+    result->append(", ");
+    result->append(".onDisappear=");
+    WriteToString(result, &value->onDisappear);
+    // Callback_Void aboutToAppear
+    result->append(", ");
+    result->append(".aboutToAppear=");
+    WriteToString(result, &value->aboutToAppear);
+    // Callback_Void aboutToDisappear
+    result->append(", ");
+    result->append(".aboutToDisappear=");
+    WriteToString(result, &value->aboutToDisappear);
+    // Ark_Padding layoutRegionMargin
+    result->append(", ");
+    result->append(".layoutRegionMargin=");
+    WriteToString(result, &value->layoutRegionMargin);
+    // Ark_ContextMenuAnimationOptions previewAnimationOptions
+    result->append(", ");
+    result->append(".previewAnimationOptions=");
+    WriteToString(result, &value->previewAnimationOptions);
+    // Ark_ResourceColor backgroundColor
+    result->append(", ");
+    result->append(".backgroundColor=");
+    WriteToString(result, &value->backgroundColor);
+    // Ark_BlurStyle backgroundBlurStyle
+    result->append(", ");
+    result->append(".backgroundBlurStyle=");
+    WriteToString(result, &value->backgroundBlurStyle);
+    // Ark_BackgroundBlurStyleOptions backgroundBlurStyleOptions
+    result->append(", ");
+    result->append(".backgroundBlurStyleOptions=");
+    WriteToString(result, &value->backgroundBlurStyleOptions);
+    // Ark_BackgroundEffectOptions backgroundEffect
+    result->append(", ");
+    result->append(".backgroundEffect=");
+    WriteToString(result, &value->backgroundEffect);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_Boolean enableHoverMode
+    result->append(", ");
+    result->append(".enableHoverMode=");
+    WriteToString(result, &value->enableHoverMode);
+    // Ark_Union_ResourceColor_EdgeColors outlineColor
+    result->append(", ");
+    result->append(".outlineColor=");
+    WriteToString(result, &value->outlineColor);
+    // Ark_Union_Dimension_EdgeOutlineWidths outlineWidth
+    result->append(", ");
+    result->append(".outlineWidth=");
+    WriteToString(result, &value->outlineWidth);
+    // Ark_HapticFeedbackMode hapticFeedbackMode
+    result->append(", ");
+    result->append(".hapticFeedbackMode=");
+    WriteToString(result, &value->hapticFeedbackMode);
+    // Ark_ResourceStr title
+    result->append(", ");
+    result->append(".title=");
+    WriteToString(result, &value->title);
+    // Ark_Boolean showInSubWindow
+    result->append(", ");
+    result->append(".showInSubWindow=");
+    WriteToString(result, &value->showInSubWindow);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_MenuOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_MenuOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_MenuOutlineOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -57926,6 +59134,121 @@ inline Ark_RuntimeType runtimeType(const Opt_PlaceholderStyle& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_PopupCommonOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_PopupCommonOptions* value) {
+    result->append("{");
+    // Ark_Placement placement
+    result->append(".placement=");
+    WriteToString(result, &value->placement);
+    // Ark_ResourceColor popupColor
+    result->append(", ");
+    result->append(".popupColor=");
+    WriteToString(result, &value->popupColor);
+    // Ark_Boolean enableArrow
+    result->append(", ");
+    result->append(".enableArrow=");
+    WriteToString(result, &value->enableArrow);
+    // Ark_Boolean autoCancel
+    result->append(", ");
+    result->append(".autoCancel=");
+    WriteToString(result, &value->autoCancel);
+    // PopupStateChangeCallback onStateChange
+    result->append(", ");
+    result->append(".onStateChange=");
+    WriteToString(result, &value->onStateChange);
+    // Ark_Length arrowOffset
+    result->append(", ");
+    result->append(".arrowOffset=");
+    WriteToString(result, &value->arrowOffset);
+    // Ark_Boolean showInSubWindow
+    result->append(", ");
+    result->append(".showInSubWindow=");
+    WriteToString(result, &value->showInSubWindow);
+    // Ark_Union_Boolean_PopupMaskType mask
+    result->append(", ");
+    result->append(".mask=");
+    WriteToString(result, &value->mask);
+    // Ark_Length targetSpace
+    result->append(", ");
+    result->append(".targetSpace=");
+    WriteToString(result, &value->targetSpace);
+    // Ark_Position offset
+    result->append(", ");
+    result->append(".offset=");
+    WriteToString(result, &value->offset);
+    // Ark_Dimension width
+    result->append(", ");
+    result->append(".width=");
+    WriteToString(result, &value->width);
+    // Ark_ArrowPointPosition arrowPointPosition
+    result->append(", ");
+    result->append(".arrowPointPosition=");
+    WriteToString(result, &value->arrowPointPosition);
+    // Ark_Dimension arrowWidth
+    result->append(", ");
+    result->append(".arrowWidth=");
+    WriteToString(result, &value->arrowWidth);
+    // Ark_Dimension arrowHeight
+    result->append(", ");
+    result->append(".arrowHeight=");
+    WriteToString(result, &value->arrowHeight);
+    // Ark_Dimension radius
+    result->append(", ");
+    result->append(".radius=");
+    WriteToString(result, &value->radius);
+    // Ark_Union_ShadowOptions_ShadowStyle shadow
+    result->append(", ");
+    result->append(".shadow=");
+    WriteToString(result, &value->shadow);
+    // Ark_BlurStyle backgroundBlurStyle
+    result->append(", ");
+    result->append(".backgroundBlurStyle=");
+    WriteToString(result, &value->backgroundBlurStyle);
+    // Ark_Boolean focusable
+    result->append(", ");
+    result->append(".focusable=");
+    WriteToString(result, &value->focusable);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
+    result->append(", ");
+    result->append(".onWillDismiss=");
+    WriteToString(result, &value->onWillDismiss);
+    // Ark_Boolean enableHoverMode
+    result->append(", ");
+    result->append(".enableHoverMode=");
+    WriteToString(result, &value->enableHoverMode);
+    // Ark_Boolean followTransformOfTarget
+    result->append(", ");
+    result->append(".followTransformOfTarget=");
+    WriteToString(result, &value->followTransformOfTarget);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_PopupCommonOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_PopupCommonOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_PopupMessageOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -59533,6 +60856,137 @@ inline Ark_RuntimeType runtimeType(const Opt_NativeEmbedTouchInfo& value)
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_PopupOptions& value)
+{
+    return INTEROP_RUNTIME_OBJECT;
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_PopupOptions* value) {
+    result->append("{");
+    // Ark_String message
+    result->append(".message=");
+    WriteToString(result, &value->message);
+    // Ark_Placement placement
+    result->append(", ");
+    result->append(".placement=");
+    WriteToString(result, &value->placement);
+    // Ark_PopupButton primaryButton
+    result->append(", ");
+    result->append(".primaryButton=");
+    WriteToString(result, &value->primaryButton);
+    // Ark_PopupButton secondaryButton
+    result->append(", ");
+    result->append(".secondaryButton=");
+    WriteToString(result, &value->secondaryButton);
+    // PopupStateChangeCallback onStateChange
+    result->append(", ");
+    result->append(".onStateChange=");
+    WriteToString(result, &value->onStateChange);
+    // Ark_Length arrowOffset
+    result->append(", ");
+    result->append(".arrowOffset=");
+    WriteToString(result, &value->arrowOffset);
+    // Ark_Boolean showInSubWindow
+    result->append(", ");
+    result->append(".showInSubWindow=");
+    WriteToString(result, &value->showInSubWindow);
+    // Ark_Union_Boolean_PopupMaskType mask
+    result->append(", ");
+    result->append(".mask=");
+    WriteToString(result, &value->mask);
+    // Ark_PopupMessageOptions messageOptions
+    result->append(", ");
+    result->append(".messageOptions=");
+    WriteToString(result, &value->messageOptions);
+    // Ark_Length targetSpace
+    result->append(", ");
+    result->append(".targetSpace=");
+    WriteToString(result, &value->targetSpace);
+    // Ark_Boolean enableArrow
+    result->append(", ");
+    result->append(".enableArrow=");
+    WriteToString(result, &value->enableArrow);
+    // Ark_Position offset
+    result->append(", ");
+    result->append(".offset=");
+    WriteToString(result, &value->offset);
+    // Ark_Union_Color_String_Resource_Number popupColor
+    result->append(", ");
+    result->append(".popupColor=");
+    WriteToString(result, &value->popupColor);
+    // Ark_Boolean autoCancel
+    result->append(", ");
+    result->append(".autoCancel=");
+    WriteToString(result, &value->autoCancel);
+    // Ark_Dimension width
+    result->append(", ");
+    result->append(".width=");
+    WriteToString(result, &value->width);
+    // Ark_ArrowPointPosition arrowPointPosition
+    result->append(", ");
+    result->append(".arrowPointPosition=");
+    WriteToString(result, &value->arrowPointPosition);
+    // Ark_Dimension arrowWidth
+    result->append(", ");
+    result->append(".arrowWidth=");
+    WriteToString(result, &value->arrowWidth);
+    // Ark_Dimension arrowHeight
+    result->append(", ");
+    result->append(".arrowHeight=");
+    WriteToString(result, &value->arrowHeight);
+    // Ark_Dimension radius
+    result->append(", ");
+    result->append(".radius=");
+    WriteToString(result, &value->radius);
+    // Ark_Union_ShadowOptions_ShadowStyle shadow
+    result->append(", ");
+    result->append(".shadow=");
+    WriteToString(result, &value->shadow);
+    // Ark_BlurStyle backgroundBlurStyle
+    result->append(", ");
+    result->append(".backgroundBlurStyle=");
+    WriteToString(result, &value->backgroundBlurStyle);
+    // Ark_TransitionEffect transition
+    result->append(", ");
+    result->append(".transition=");
+    WriteToString(result, &value->transition);
+    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
+    result->append(", ");
+    result->append(".onWillDismiss=");
+    WriteToString(result, &value->onWillDismiss);
+    // Ark_Boolean enableHoverMode
+    result->append(", ");
+    result->append(".enableHoverMode=");
+    WriteToString(result, &value->enableHoverMode);
+    // Ark_Boolean followTransformOfTarget
+    result->append(", ");
+    result->append(".followTransformOfTarget=");
+    WriteToString(result, &value->followTransformOfTarget);
+    // Ark_KeyboardAvoidMode keyboardAvoidMode
+    result->append(", ");
+    result->append(".keyboardAvoidMode=");
+    WriteToString(result, &value->keyboardAvoidMode);
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_PopupOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_PopupOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_ResourceImageAttachmentOptions& value)
 {
     return INTEROP_RUNTIME_OBJECT;
@@ -60384,6 +61838,51 @@ inline Ark_RuntimeType runtimeType(const Opt_Union_ComponentContent_SubTabBarSty
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
 template <>
+inline Ark_RuntimeType runtimeType(const Ark_Union_PopupOptions_CustomPopupOptions& value)
+{
+    switch (value.selector) {
+        case 0: return runtimeType(value.value0);
+        case 1: return runtimeType(value.value1);
+        default: INTEROP_FATAL("Bad selector in Ark_Union_PopupOptions_CustomPopupOptions: %d", value.selector);
+    }
+}
+template <>
+inline void WriteToString(std::string* result, const Ark_Union_PopupOptions_CustomPopupOptions* value) {
+    result->append("{");
+    result->append(".selector=");
+    result->append(std::to_string(value->selector));
+    result->append(", ");
+    // Ark_PopupOptions
+    if (value->selector == 0) {
+        result->append(".value0=");
+        WriteToString(result, &value->value0);
+    }
+    // Ark_CustomPopupOptions
+    if (value->selector == 1) {
+        result->append(".value1=");
+        WriteToString(result, &value->value1);
+    }
+    result->append("}");
+}
+template <>
+inline void WriteToString(std::string* result, const Opt_Union_PopupOptions_CustomPopupOptions* value) {
+    result->append("{.tag=");
+    result->append(tagNameExact((Ark_Tag)(value->tag)));
+    result->append(", .value=");
+    if (value->tag != INTEROP_TAG_UNDEFINED) {
+        WriteToString(result, &value->value);
+    } else {
+        Ark_Undefined undefined = { 0 };
+        WriteToString(result, undefined);
+    }
+    result->append("}");
+}
+template <>
+inline Ark_RuntimeType runtimeType(const Opt_Union_PopupOptions_CustomPopupOptions& value)
+{
+    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
+}
+template <>
 inline Ark_RuntimeType runtimeType(const Ark_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions& value)
 {
     switch (value.selector) {
@@ -60953,818 +62452,6 @@ inline Ark_RuntimeType runtimeType(const Opt_Union_ImageAttachmentInterface_Opt_
 {
     return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
 }
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_AsymmetricTransitionOption& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_AsymmetricTransitionOption* value) {
-    result->append("{");
-    // Ark_TransitionEffect appear
-    result->append(".appear=");
-    WriteToString(result, value->appear);
-    // Ark_TransitionEffect disappear
-    result->append(", ");
-    result->append(".disappear=");
-    WriteToString(result, value->disappear);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_AsymmetricTransitionOption* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_AsymmetricTransitionOption& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_ContentCoverOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_ContentCoverOptions* value) {
-    result->append("{");
-    // Ark_ResourceColor backgroundColor
-    result->append(".backgroundColor=");
-    WriteToString(result, &value->backgroundColor);
-    // Callback_Void onAppear
-    result->append(", ");
-    result->append(".onAppear=");
-    WriteToString(result, &value->onAppear);
-    // Callback_Void onDisappear
-    result->append(", ");
-    result->append(".onDisappear=");
-    WriteToString(result, &value->onDisappear);
-    // Callback_Void onWillAppear
-    result->append(", ");
-    result->append(".onWillAppear=");
-    WriteToString(result, &value->onWillAppear);
-    // Callback_Void onWillDisappear
-    result->append(", ");
-    result->append(".onWillDisappear=");
-    WriteToString(result, &value->onWillDisappear);
-    // Ark_ModalTransition modalTransition
-    result->append(", ");
-    result->append(".modalTransition=");
-    WriteToString(result, &value->modalTransition);
-    // Callback_DismissContentCoverAction_Void onWillDismiss
-    result->append(", ");
-    result->append(".onWillDismiss=");
-    WriteToString(result, &value->onWillDismiss);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_ContentCoverOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_ContentCoverOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_ContextMenuAnimationOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_ContextMenuAnimationOptions* value) {
-    result->append("{");
-    // Ark_AnimationNumberRange scale
-    result->append(".scale=");
-    WriteToString(result, &value->scale);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_AnimationNumberRange hoverScale
-    result->append(", ");
-    result->append(".hoverScale=");
-    WriteToString(result, &value->hoverScale);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_ContextMenuAnimationOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_ContextMenuAnimationOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_ContextMenuOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_ContextMenuOptions* value) {
-    result->append("{");
-    // Ark_Position offset
-    result->append(".offset=");
-    WriteToString(result, &value->offset);
-    // Ark_Placement placement
-    result->append(", ");
-    result->append(".placement=");
-    WriteToString(result, &value->placement);
-    // Ark_Boolean enableArrow
-    result->append(", ");
-    result->append(".enableArrow=");
-    WriteToString(result, &value->enableArrow);
-    // Ark_Length arrowOffset
-    result->append(", ");
-    result->append(".arrowOffset=");
-    WriteToString(result, &value->arrowOffset);
-    // Ark_Union_MenuPreviewMode_CustomBuilder preview
-    result->append(", ");
-    result->append(".preview=");
-    WriteToString(result, &value->preview);
-    // Ark_BorderRadiusType previewBorderRadius
-    result->append(", ");
-    result->append(".previewBorderRadius=");
-    WriteToString(result, &value->previewBorderRadius);
-    // Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius
-    result->append(", ");
-    result->append(".borderRadius=");
-    WriteToString(result, &value->borderRadius);
-    // Callback_Void onAppear
-    result->append(", ");
-    result->append(".onAppear=");
-    WriteToString(result, &value->onAppear);
-    // Callback_Void onDisappear
-    result->append(", ");
-    result->append(".onDisappear=");
-    WriteToString(result, &value->onDisappear);
-    // Callback_Void aboutToAppear
-    result->append(", ");
-    result->append(".aboutToAppear=");
-    WriteToString(result, &value->aboutToAppear);
-    // Callback_Void aboutToDisappear
-    result->append(", ");
-    result->append(".aboutToDisappear=");
-    WriteToString(result, &value->aboutToDisappear);
-    // Ark_Padding layoutRegionMargin
-    result->append(", ");
-    result->append(".layoutRegionMargin=");
-    WriteToString(result, &value->layoutRegionMargin);
-    // Ark_ContextMenuAnimationOptions previewAnimationOptions
-    result->append(", ");
-    result->append(".previewAnimationOptions=");
-    WriteToString(result, &value->previewAnimationOptions);
-    // Ark_ResourceColor backgroundColor
-    result->append(", ");
-    result->append(".backgroundColor=");
-    WriteToString(result, &value->backgroundColor);
-    // Ark_BlurStyle backgroundBlurStyle
-    result->append(", ");
-    result->append(".backgroundBlurStyle=");
-    WriteToString(result, &value->backgroundBlurStyle);
-    // Ark_BackgroundBlurStyleOptions backgroundBlurStyleOptions
-    result->append(", ");
-    result->append(".backgroundBlurStyleOptions=");
-    WriteToString(result, &value->backgroundBlurStyleOptions);
-    // Ark_BackgroundEffectOptions backgroundEffect
-    result->append(", ");
-    result->append(".backgroundEffect=");
-    WriteToString(result, &value->backgroundEffect);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_Boolean enableHoverMode
-    result->append(", ");
-    result->append(".enableHoverMode=");
-    WriteToString(result, &value->enableHoverMode);
-    // Ark_Union_ResourceColor_EdgeColors outlineColor
-    result->append(", ");
-    result->append(".outlineColor=");
-    WriteToString(result, &value->outlineColor);
-    // Ark_Union_Dimension_EdgeOutlineWidths outlineWidth
-    result->append(", ");
-    result->append(".outlineWidth=");
-    WriteToString(result, &value->outlineWidth);
-    // Ark_HapticFeedbackMode hapticFeedbackMode
-    result->append(", ");
-    result->append(".hapticFeedbackMode=");
-    WriteToString(result, &value->hapticFeedbackMode);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_ContextMenuOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_ContextMenuOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_CustomPopupOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_CustomPopupOptions* value) {
-    result->append("{");
-    // CustomNodeBuilder builder
-    result->append(".builder=");
-    WriteToString(result, &value->builder);
-    // Ark_Placement placement
-    result->append(", ");
-    result->append(".placement=");
-    WriteToString(result, &value->placement);
-    // Ark_Union_Color_String_Resource_Number popupColor
-    result->append(", ");
-    result->append(".popupColor=");
-    WriteToString(result, &value->popupColor);
-    // Ark_Boolean enableArrow
-    result->append(", ");
-    result->append(".enableArrow=");
-    WriteToString(result, &value->enableArrow);
-    // Ark_Boolean autoCancel
-    result->append(", ");
-    result->append(".autoCancel=");
-    WriteToString(result, &value->autoCancel);
-    // PopupStateChangeCallback onStateChange
-    result->append(", ");
-    result->append(".onStateChange=");
-    WriteToString(result, &value->onStateChange);
-    // Ark_Length arrowOffset
-    result->append(", ");
-    result->append(".arrowOffset=");
-    WriteToString(result, &value->arrowOffset);
-    // Ark_Boolean showInSubWindow
-    result->append(", ");
-    result->append(".showInSubWindow=");
-    WriteToString(result, &value->showInSubWindow);
-    // Ark_Union_Boolean_PopupMaskType mask
-    result->append(", ");
-    result->append(".mask=");
-    WriteToString(result, &value->mask);
-    // Ark_Length targetSpace
-    result->append(", ");
-    result->append(".targetSpace=");
-    WriteToString(result, &value->targetSpace);
-    // Ark_Position offset
-    result->append(", ");
-    result->append(".offset=");
-    WriteToString(result, &value->offset);
-    // Ark_Dimension width
-    result->append(", ");
-    result->append(".width=");
-    WriteToString(result, &value->width);
-    // Ark_ArrowPointPosition arrowPointPosition
-    result->append(", ");
-    result->append(".arrowPointPosition=");
-    WriteToString(result, &value->arrowPointPosition);
-    // Ark_Dimension arrowWidth
-    result->append(", ");
-    result->append(".arrowWidth=");
-    WriteToString(result, &value->arrowWidth);
-    // Ark_Dimension arrowHeight
-    result->append(", ");
-    result->append(".arrowHeight=");
-    WriteToString(result, &value->arrowHeight);
-    // Ark_Dimension radius
-    result->append(", ");
-    result->append(".radius=");
-    WriteToString(result, &value->radius);
-    // Ark_Union_ShadowOptions_ShadowStyle shadow
-    result->append(", ");
-    result->append(".shadow=");
-    WriteToString(result, &value->shadow);
-    // Ark_BlurStyle backgroundBlurStyle
-    result->append(", ");
-    result->append(".backgroundBlurStyle=");
-    WriteToString(result, &value->backgroundBlurStyle);
-    // Ark_Boolean focusable
-    result->append(", ");
-    result->append(".focusable=");
-    WriteToString(result, &value->focusable);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
-    result->append(", ");
-    result->append(".onWillDismiss=");
-    WriteToString(result, &value->onWillDismiss);
-    // Ark_Boolean enableHoverMode
-    result->append(", ");
-    result->append(".enableHoverMode=");
-    WriteToString(result, &value->enableHoverMode);
-    // Ark_Boolean followTransformOfTarget
-    result->append(", ");
-    result->append(".followTransformOfTarget=");
-    WriteToString(result, &value->followTransformOfTarget);
-    // Ark_KeyboardAvoidMode keyboardAvoidMode
-    result->append(", ");
-    result->append(".keyboardAvoidMode=");
-    WriteToString(result, &value->keyboardAvoidMode);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_CustomPopupOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_CustomPopupOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_MenuOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_MenuOptions* value) {
-    result->append("{");
-    // Ark_Position offset
-    result->append(".offset=");
-    WriteToString(result, &value->offset);
-    // Ark_Placement placement
-    result->append(", ");
-    result->append(".placement=");
-    WriteToString(result, &value->placement);
-    // Ark_Boolean enableArrow
-    result->append(", ");
-    result->append(".enableArrow=");
-    WriteToString(result, &value->enableArrow);
-    // Ark_Length arrowOffset
-    result->append(", ");
-    result->append(".arrowOffset=");
-    WriteToString(result, &value->arrowOffset);
-    // Ark_Union_MenuPreviewMode_CustomBuilder preview
-    result->append(", ");
-    result->append(".preview=");
-    WriteToString(result, &value->preview);
-    // Ark_BorderRadiusType previewBorderRadius
-    result->append(", ");
-    result->append(".previewBorderRadius=");
-    WriteToString(result, &value->previewBorderRadius);
-    // Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius
-    result->append(", ");
-    result->append(".borderRadius=");
-    WriteToString(result, &value->borderRadius);
-    // Callback_Void onAppear
-    result->append(", ");
-    result->append(".onAppear=");
-    WriteToString(result, &value->onAppear);
-    // Callback_Void onDisappear
-    result->append(", ");
-    result->append(".onDisappear=");
-    WriteToString(result, &value->onDisappear);
-    // Callback_Void aboutToAppear
-    result->append(", ");
-    result->append(".aboutToAppear=");
-    WriteToString(result, &value->aboutToAppear);
-    // Callback_Void aboutToDisappear
-    result->append(", ");
-    result->append(".aboutToDisappear=");
-    WriteToString(result, &value->aboutToDisappear);
-    // Ark_Padding layoutRegionMargin
-    result->append(", ");
-    result->append(".layoutRegionMargin=");
-    WriteToString(result, &value->layoutRegionMargin);
-    // Ark_ContextMenuAnimationOptions previewAnimationOptions
-    result->append(", ");
-    result->append(".previewAnimationOptions=");
-    WriteToString(result, &value->previewAnimationOptions);
-    // Ark_ResourceColor backgroundColor
-    result->append(", ");
-    result->append(".backgroundColor=");
-    WriteToString(result, &value->backgroundColor);
-    // Ark_BlurStyle backgroundBlurStyle
-    result->append(", ");
-    result->append(".backgroundBlurStyle=");
-    WriteToString(result, &value->backgroundBlurStyle);
-    // Ark_BackgroundBlurStyleOptions backgroundBlurStyleOptions
-    result->append(", ");
-    result->append(".backgroundBlurStyleOptions=");
-    WriteToString(result, &value->backgroundBlurStyleOptions);
-    // Ark_BackgroundEffectOptions backgroundEffect
-    result->append(", ");
-    result->append(".backgroundEffect=");
-    WriteToString(result, &value->backgroundEffect);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_Boolean enableHoverMode
-    result->append(", ");
-    result->append(".enableHoverMode=");
-    WriteToString(result, &value->enableHoverMode);
-    // Ark_Union_ResourceColor_EdgeColors outlineColor
-    result->append(", ");
-    result->append(".outlineColor=");
-    WriteToString(result, &value->outlineColor);
-    // Ark_Union_Dimension_EdgeOutlineWidths outlineWidth
-    result->append(", ");
-    result->append(".outlineWidth=");
-    WriteToString(result, &value->outlineWidth);
-    // Ark_HapticFeedbackMode hapticFeedbackMode
-    result->append(", ");
-    result->append(".hapticFeedbackMode=");
-    WriteToString(result, &value->hapticFeedbackMode);
-    // Ark_ResourceStr title
-    result->append(", ");
-    result->append(".title=");
-    WriteToString(result, &value->title);
-    // Ark_Boolean showInSubWindow
-    result->append(", ");
-    result->append(".showInSubWindow=");
-    WriteToString(result, &value->showInSubWindow);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_MenuOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_MenuOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_PopupCommonOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_PopupCommonOptions* value) {
-    result->append("{");
-    // Ark_Placement placement
-    result->append(".placement=");
-    WriteToString(result, &value->placement);
-    // Ark_ResourceColor popupColor
-    result->append(", ");
-    result->append(".popupColor=");
-    WriteToString(result, &value->popupColor);
-    // Ark_Boolean enableArrow
-    result->append(", ");
-    result->append(".enableArrow=");
-    WriteToString(result, &value->enableArrow);
-    // Ark_Boolean autoCancel
-    result->append(", ");
-    result->append(".autoCancel=");
-    WriteToString(result, &value->autoCancel);
-    // PopupStateChangeCallback onStateChange
-    result->append(", ");
-    result->append(".onStateChange=");
-    WriteToString(result, &value->onStateChange);
-    // Ark_Length arrowOffset
-    result->append(", ");
-    result->append(".arrowOffset=");
-    WriteToString(result, &value->arrowOffset);
-    // Ark_Boolean showInSubWindow
-    result->append(", ");
-    result->append(".showInSubWindow=");
-    WriteToString(result, &value->showInSubWindow);
-    // Ark_Union_Boolean_PopupMaskType mask
-    result->append(", ");
-    result->append(".mask=");
-    WriteToString(result, &value->mask);
-    // Ark_Length targetSpace
-    result->append(", ");
-    result->append(".targetSpace=");
-    WriteToString(result, &value->targetSpace);
-    // Ark_Position offset
-    result->append(", ");
-    result->append(".offset=");
-    WriteToString(result, &value->offset);
-    // Ark_Dimension width
-    result->append(", ");
-    result->append(".width=");
-    WriteToString(result, &value->width);
-    // Ark_ArrowPointPosition arrowPointPosition
-    result->append(", ");
-    result->append(".arrowPointPosition=");
-    WriteToString(result, &value->arrowPointPosition);
-    // Ark_Dimension arrowWidth
-    result->append(", ");
-    result->append(".arrowWidth=");
-    WriteToString(result, &value->arrowWidth);
-    // Ark_Dimension arrowHeight
-    result->append(", ");
-    result->append(".arrowHeight=");
-    WriteToString(result, &value->arrowHeight);
-    // Ark_Dimension radius
-    result->append(", ");
-    result->append(".radius=");
-    WriteToString(result, &value->radius);
-    // Ark_Union_ShadowOptions_ShadowStyle shadow
-    result->append(", ");
-    result->append(".shadow=");
-    WriteToString(result, &value->shadow);
-    // Ark_BlurStyle backgroundBlurStyle
-    result->append(", ");
-    result->append(".backgroundBlurStyle=");
-    WriteToString(result, &value->backgroundBlurStyle);
-    // Ark_Boolean focusable
-    result->append(", ");
-    result->append(".focusable=");
-    WriteToString(result, &value->focusable);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
-    result->append(", ");
-    result->append(".onWillDismiss=");
-    WriteToString(result, &value->onWillDismiss);
-    // Ark_Boolean enableHoverMode
-    result->append(", ");
-    result->append(".enableHoverMode=");
-    WriteToString(result, &value->enableHoverMode);
-    // Ark_Boolean followTransformOfTarget
-    result->append(", ");
-    result->append(".followTransformOfTarget=");
-    WriteToString(result, &value->followTransformOfTarget);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_PopupCommonOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_PopupCommonOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_PopupOptions& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_PopupOptions* value) {
-    result->append("{");
-    // Ark_String message
-    result->append(".message=");
-    WriteToString(result, &value->message);
-    // Ark_Placement placement
-    result->append(", ");
-    result->append(".placement=");
-    WriteToString(result, &value->placement);
-    // Ark_PopupButton primaryButton
-    result->append(", ");
-    result->append(".primaryButton=");
-    WriteToString(result, &value->primaryButton);
-    // Ark_PopupButton secondaryButton
-    result->append(", ");
-    result->append(".secondaryButton=");
-    WriteToString(result, &value->secondaryButton);
-    // PopupStateChangeCallback onStateChange
-    result->append(", ");
-    result->append(".onStateChange=");
-    WriteToString(result, &value->onStateChange);
-    // Ark_Length arrowOffset
-    result->append(", ");
-    result->append(".arrowOffset=");
-    WriteToString(result, &value->arrowOffset);
-    // Ark_Boolean showInSubWindow
-    result->append(", ");
-    result->append(".showInSubWindow=");
-    WriteToString(result, &value->showInSubWindow);
-    // Ark_Union_Boolean_PopupMaskType mask
-    result->append(", ");
-    result->append(".mask=");
-    WriteToString(result, &value->mask);
-    // Ark_PopupMessageOptions messageOptions
-    result->append(", ");
-    result->append(".messageOptions=");
-    WriteToString(result, &value->messageOptions);
-    // Ark_Length targetSpace
-    result->append(", ");
-    result->append(".targetSpace=");
-    WriteToString(result, &value->targetSpace);
-    // Ark_Boolean enableArrow
-    result->append(", ");
-    result->append(".enableArrow=");
-    WriteToString(result, &value->enableArrow);
-    // Ark_Position offset
-    result->append(", ");
-    result->append(".offset=");
-    WriteToString(result, &value->offset);
-    // Ark_Union_Color_String_Resource_Number popupColor
-    result->append(", ");
-    result->append(".popupColor=");
-    WriteToString(result, &value->popupColor);
-    // Ark_Boolean autoCancel
-    result->append(", ");
-    result->append(".autoCancel=");
-    WriteToString(result, &value->autoCancel);
-    // Ark_Dimension width
-    result->append(", ");
-    result->append(".width=");
-    WriteToString(result, &value->width);
-    // Ark_ArrowPointPosition arrowPointPosition
-    result->append(", ");
-    result->append(".arrowPointPosition=");
-    WriteToString(result, &value->arrowPointPosition);
-    // Ark_Dimension arrowWidth
-    result->append(", ");
-    result->append(".arrowWidth=");
-    WriteToString(result, &value->arrowWidth);
-    // Ark_Dimension arrowHeight
-    result->append(", ");
-    result->append(".arrowHeight=");
-    WriteToString(result, &value->arrowHeight);
-    // Ark_Dimension radius
-    result->append(", ");
-    result->append(".radius=");
-    WriteToString(result, &value->radius);
-    // Ark_Union_ShadowOptions_ShadowStyle shadow
-    result->append(", ");
-    result->append(".shadow=");
-    WriteToString(result, &value->shadow);
-    // Ark_BlurStyle backgroundBlurStyle
-    result->append(", ");
-    result->append(".backgroundBlurStyle=");
-    WriteToString(result, &value->backgroundBlurStyle);
-    // Ark_TransitionEffect transition
-    result->append(", ");
-    result->append(".transition=");
-    WriteToString(result, &value->transition);
-    // Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss
-    result->append(", ");
-    result->append(".onWillDismiss=");
-    WriteToString(result, &value->onWillDismiss);
-    // Ark_Boolean enableHoverMode
-    result->append(", ");
-    result->append(".enableHoverMode=");
-    WriteToString(result, &value->enableHoverMode);
-    // Ark_Boolean followTransformOfTarget
-    result->append(", ");
-    result->append(".followTransformOfTarget=");
-    WriteToString(result, &value->followTransformOfTarget);
-    // Ark_KeyboardAvoidMode keyboardAvoidMode
-    result->append(", ");
-    result->append(".keyboardAvoidMode=");
-    WriteToString(result, &value->keyboardAvoidMode);
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_PopupOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_PopupOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_TransitionEffect& value)
-{
-    return INTEROP_RUNTIME_OBJECT;
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_TransitionEffect value) {
-    WriteToString(result, static_cast<InteropNativePointer>(value));
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_TransitionEffect* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_TransitionEffect& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Ark_Union_PopupOptions_CustomPopupOptions& value)
-{
-    switch (value.selector) {
-        case 0: return runtimeType(value.value0);
-        case 1: return runtimeType(value.value1);
-        default: INTEROP_FATAL("Bad selector in Ark_Union_PopupOptions_CustomPopupOptions: %d", value.selector);
-    }
-}
-template <>
-inline void WriteToString(std::string* result, const Ark_Union_PopupOptions_CustomPopupOptions* value) {
-    result->append("{");
-    result->append(".selector=");
-    result->append(std::to_string(value->selector));
-    result->append(", ");
-    // Ark_PopupOptions
-    if (value->selector == 0) {
-        result->append(".value0=");
-        WriteToString(result, &value->value0);
-    }
-    // Ark_CustomPopupOptions
-    if (value->selector == 1) {
-        result->append(".value1=");
-        WriteToString(result, &value->value1);
-    }
-    result->append("}");
-}
-template <>
-inline void WriteToString(std::string* result, const Opt_Union_PopupOptions_CustomPopupOptions* value) {
-    result->append("{.tag=");
-    result->append(tagNameExact((Ark_Tag)(value->tag)));
-    result->append(", .value=");
-    if (value->tag != INTEROP_TAG_UNDEFINED) {
-        WriteToString(result, &value->value);
-    } else {
-        Ark_Undefined undefined = { 0 };
-        WriteToString(result, undefined);
-    }
-    result->append("}");
-}
-template <>
-inline Ark_RuntimeType runtimeType(const Opt_Union_PopupOptions_CustomPopupOptions& value)
-{
-    return (value.tag != INTEROP_TAG_UNDEFINED) ? (INTEROP_RUNTIME_OBJECT) : (INTEROP_RUNTIME_UNDEFINED);
-}
 
 class BaseContext_serializer {
     public:
@@ -61781,6 +62468,11 @@ class BuilderNodeOps_serializer {
     static void write(SerializerBase& buffer, Ark_BuilderNodeOps value);
     static Ark_BuilderNodeOps read(DeserializerBase& buffer);
 };
+class CalendarController_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CalendarController value);
+    static Ark_CalendarController read(DeserializerBase& buffer);
+};
 class CalendarPickerDialog_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CalendarPickerDialog value);
@@ -62761,6 +63453,11 @@ class TouchTestInfo_serializer {
     static void write(SerializerBase& buffer, Ark_TouchTestInfo value);
     static Ark_TouchTestInfo read(DeserializerBase& buffer);
 };
+class TransitionEffect_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_TransitionEffect value);
+    static Ark_TransitionEffect read(DeserializerBase& buffer);
+};
 class TranslateResult_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_TranslateResult value);
@@ -62916,6 +63613,11 @@ class ASTCResource_serializer {
     static void write(SerializerBase& buffer, Ark_ASTCResource value);
     static Ark_ASTCResource read(DeserializerBase& buffer);
 };
+class AsymmetricTransitionOption_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_AsymmetricTransitionOption value);
+    static Ark_AsymmetricTransitionOption read(DeserializerBase& buffer);
+};
 class AutoPlayOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_AutoPlayOptions value);
@@ -62991,6 +63693,21 @@ class ButtonOptions_serializer {
     static void write(SerializerBase& buffer, Ark_ButtonOptions value);
     static Ark_ButtonOptions read(DeserializerBase& buffer);
 };
+class CalendarDay_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CalendarDay value);
+    static Ark_CalendarDay read(DeserializerBase& buffer);
+};
+class CalendarRequestedData_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CalendarRequestedData value);
+    static Ark_CalendarRequestedData read(DeserializerBase& buffer);
+};
+class CalendarSelectedDate_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CalendarSelectedDate value);
+    static Ark_CalendarSelectedDate read(DeserializerBase& buffer);
+};
 class CancelButtonSymbolOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CancelButtonSymbolOptions value);
@@ -63606,6 +64323,11 @@ class MessageEvents_serializer {
     static void write(SerializerBase& buffer, Ark_MessageEvents value);
     static Ark_MessageEvents read(DeserializerBase& buffer);
 };
+class MonthData_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_MonthData value);
+    static Ark_MonthData read(DeserializerBase& buffer);
+};
 class MotionBlurAnchor_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_MotionBlurAnchor value);
@@ -64346,6 +65068,11 @@ class CalendarOptions_serializer {
     static void write(SerializerBase& buffer, Ark_CalendarOptions value);
     static Ark_CalendarOptions read(DeserializerBase& buffer);
 };
+class CalendarRequestedMonths_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CalendarRequestedMonths value);
+    static Ark_CalendarRequestedMonths read(DeserializerBase& buffer);
+};
 class CanvasRenderer_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CanvasRenderer value);
@@ -64371,11 +65098,26 @@ class ComponentInfo_serializer {
     static void write(SerializerBase& buffer, Ark_ComponentInfo value);
     static Ark_ComponentInfo read(DeserializerBase& buffer);
 };
+class ContentCoverOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_ContentCoverOptions value);
+    static Ark_ContentCoverOptions read(DeserializerBase& buffer);
+};
+class ContextMenuAnimationOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_ContextMenuAnimationOptions value);
+    static Ark_ContextMenuAnimationOptions read(DeserializerBase& buffer);
+};
 class CopyEvent_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CopyEvent value);
     static Ark_CopyEvent read(DeserializerBase& buffer);
 };
+class CurrentDayStyle_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CurrentDayStyle value);
+    static Ark_CurrentDayStyle read(DeserializerBase& buffer);
+};
 class CutEvent_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CutEvent value);
@@ -64581,6 +65323,11 @@ class NavigationTransitionProxy_serializer {
     static void write(SerializerBase& buffer, Ark_NavigationTransitionProxy value);
     static Ark_NavigationTransitionProxy read(DeserializerBase& buffer);
 };
+class NonCurrentDayStyle_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_NonCurrentDayStyle value);
+    static Ark_NonCurrentDayStyle read(DeserializerBase& buffer);
+};
 class OffscreenCanvasRenderingContext2D_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_OffscreenCanvasRenderingContext2D value);
@@ -64801,6 +65548,11 @@ class TextStyleInterface_serializer {
     static void write(SerializerBase& buffer, Ark_TextStyleInterface value);
     static Ark_TextStyleInterface read(DeserializerBase& buffer);
 };
+class TodayStyle_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_TodayStyle value);
+    static Ark_TodayStyle read(DeserializerBase& buffer);
+};
 class ToolbarItem_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_ToolbarItem value);
@@ -64816,6 +65568,16 @@ class VideoOptions_serializer {
     static void write(SerializerBase& buffer, Ark_VideoOptions value);
     static Ark_VideoOptions read(DeserializerBase& buffer);
 };
+class WeekStyle_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_WeekStyle value);
+    static Ark_WeekStyle read(DeserializerBase& buffer);
+};
+class WorkStateStyle_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_WorkStateStyle value);
+    static Ark_WorkStateStyle read(DeserializerBase& buffer);
+};
 class XComponentOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_XComponentOptions value);
@@ -65156,11 +65918,21 @@ class CapsuleStyleOptions_serializer {
     static void write(SerializerBase& buffer, Ark_CapsuleStyleOptions value);
     static Ark_CapsuleStyleOptions read(DeserializerBase& buffer);
 };
+class ContextMenuOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_ContextMenuOptions value);
+    static Ark_ContextMenuOptions read(DeserializerBase& buffer);
+};
 class CustomDialogControllerOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_CustomDialogControllerOptions value);
     static Ark_CustomDialogControllerOptions read(DeserializerBase& buffer);
 };
+class CustomPopupOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_CustomPopupOptions value);
+    static Ark_CustomPopupOptions read(DeserializerBase& buffer);
+};
 class DigitIndicator_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_DigitIndicator value);
@@ -65211,6 +65983,11 @@ class LongPressGestureEvent_serializer {
     static void write(SerializerBase& buffer, Ark_LongPressGestureEvent value);
     static Ark_LongPressGestureEvent read(DeserializerBase& buffer);
 };
+class MenuOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_MenuOptions value);
+    static Ark_MenuOptions read(DeserializerBase& buffer);
+};
 class MenuOutlineOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_MenuOutlineOptions value);
@@ -65276,6 +66053,11 @@ class PlaceholderStyle_serializer {
     static void write(SerializerBase& buffer, Ark_PlaceholderStyle value);
     static Ark_PlaceholderStyle read(DeserializerBase& buffer);
 };
+class PopupCommonOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_PopupCommonOptions value);
+    static Ark_PopupCommonOptions read(DeserializerBase& buffer);
+};
 class PopupMessageOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_PopupMessageOptions value);
@@ -65426,6 +66208,11 @@ class NativeEmbedTouchInfo_serializer {
     static void write(SerializerBase& buffer, Ark_NativeEmbedTouchInfo value);
     static Ark_NativeEmbedTouchInfo read(DeserializerBase& buffer);
 };
+class PopupOptions_serializer {
+    public:
+    static void write(SerializerBase& buffer, Ark_PopupOptions value);
+    static Ark_PopupOptions read(DeserializerBase& buffer);
+};
 class ResourceImageAttachmentOptions_serializer {
     public:
     static void write(SerializerBase& buffer, Ark_ResourceImageAttachmentOptions value);
@@ -65506,51 +66293,6 @@ class SpanStyle_serializer {
     static void write(SerializerBase& buffer, Ark_SpanStyle value);
     static Ark_SpanStyle read(DeserializerBase& buffer);
 };
-class AsymmetricTransitionOption_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_AsymmetricTransitionOption value);
-    static Ark_AsymmetricTransitionOption read(DeserializerBase& buffer);
-};
-class ContentCoverOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_ContentCoverOptions value);
-    static Ark_ContentCoverOptions read(DeserializerBase& buffer);
-};
-class ContextMenuAnimationOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_ContextMenuAnimationOptions value);
-    static Ark_ContextMenuAnimationOptions read(DeserializerBase& buffer);
-};
-class ContextMenuOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_ContextMenuOptions value);
-    static Ark_ContextMenuOptions read(DeserializerBase& buffer);
-};
-class CustomPopupOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_CustomPopupOptions value);
-    static Ark_CustomPopupOptions read(DeserializerBase& buffer);
-};
-class MenuOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_MenuOptions value);
-    static Ark_MenuOptions read(DeserializerBase& buffer);
-};
-class PopupCommonOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_PopupCommonOptions value);
-    static Ark_PopupCommonOptions read(DeserializerBase& buffer);
-};
-class PopupOptions_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_PopupOptions value);
-    static Ark_PopupOptions read(DeserializerBase& buffer);
-};
-class TransitionEffect_serializer {
-    public:
-    static void write(SerializerBase& buffer, Ark_TransitionEffect value);
-    static Ark_TransitionEffect read(DeserializerBase& buffer);
-};
 inline void BaseContext_serializer::write(SerializerBase& buffer, Ark_BaseContext value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -65584,6 +66326,17 @@ inline Ark_BuilderNodeOps BuilderNodeOps_serializer::read(DeserializerBase& buff
     Ark_NativePointer ptr = valueDeserializer.readPointer();
     return static_cast<Ark_BuilderNodeOps>(ptr);
 }
+inline void CalendarController_serializer::write(SerializerBase& buffer, Ark_CalendarController value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_CalendarController CalendarController_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_CalendarController>(ptr);
+}
 inline void CalendarPickerDialog_serializer::write(SerializerBase& buffer, Ark_CalendarPickerDialog value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -68041,6 +68794,17 @@ inline Ark_TouchTestInfo TouchTestInfo_serializer::read(DeserializerBase& buffer
     value.id = static_cast<Ark_String>(valueDeserializer.readString());
     return value;
 }
+inline void TransitionEffect_serializer::write(SerializerBase& buffer, Ark_TransitionEffect value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_TransitionEffect TransitionEffect_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_TransitionEffect>(ptr);
+}
 inline void TranslateResult_serializer::write(SerializerBase& buffer, Ark_TranslateResult value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -68475,6 +69239,22 @@ inline Ark_ASTCResource ASTCResource_serializer::read(DeserializerBase& buffer)
     value.column = static_cast<Ark_Number>(valueDeserializer.readNumber());
     return value;
 }
+inline void AsymmetricTransitionOption_serializer::write(SerializerBase& buffer, Ark_AsymmetricTransitionOption value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_appear = value.appear;
+    TransitionEffect_serializer::write(valueSerializer, value_appear);
+    const auto value_disappear = value.disappear;
+    TransitionEffect_serializer::write(valueSerializer, value_disappear);
+}
+inline Ark_AsymmetricTransitionOption AsymmetricTransitionOption_serializer::read(DeserializerBase& buffer)
+{
+    Ark_AsymmetricTransitionOption value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.appear = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    value.disappear = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    return value;
+}
 inline void AutoPlayOptions_serializer::write(SerializerBase& buffer, Ark_AutoPlayOptions value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -68970,6 +69750,93 @@ inline Ark_ButtonOptions ButtonOptions_serializer::read(DeserializerBase& buffer
     value.role = role_buf;
     return value;
 }
+inline void CalendarDay_serializer::write(SerializerBase& buffer, Ark_CalendarDay value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_index = value.index;
+    valueSerializer.writeNumber(value_index);
+    const auto value_lunarMonth = value.lunarMonth;
+    valueSerializer.writeString(value_lunarMonth);
+    const auto value_lunarDay = value.lunarDay;
+    valueSerializer.writeString(value_lunarDay);
+    const auto value_dayMark = value.dayMark;
+    valueSerializer.writeString(value_dayMark);
+    const auto value_dayMarkValue = value.dayMarkValue;
+    valueSerializer.writeString(value_dayMarkValue);
+    const auto value_year = value.year;
+    valueSerializer.writeNumber(value_year);
+    const auto value_month = value.month;
+    valueSerializer.writeNumber(value_month);
+    const auto value_day = value.day;
+    valueSerializer.writeNumber(value_day);
+    const auto value_isFirstOfLunar = value.isFirstOfLunar;
+    valueSerializer.writeBoolean(value_isFirstOfLunar);
+    const auto value_hasSchedule = value.hasSchedule;
+    valueSerializer.writeBoolean(value_hasSchedule);
+    const auto value_markLunarDay = value.markLunarDay;
+    valueSerializer.writeBoolean(value_markLunarDay);
+}
+inline Ark_CalendarDay CalendarDay_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CalendarDay value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.index = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.lunarMonth = static_cast<Ark_String>(valueDeserializer.readString());
+    value.lunarDay = static_cast<Ark_String>(valueDeserializer.readString());
+    value.dayMark = static_cast<Ark_String>(valueDeserializer.readString());
+    value.dayMarkValue = static_cast<Ark_String>(valueDeserializer.readString());
+    value.year = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.month = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.day = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.isFirstOfLunar = valueDeserializer.readBoolean();
+    value.hasSchedule = valueDeserializer.readBoolean();
+    value.markLunarDay = valueDeserializer.readBoolean();
+    return value;
+}
+inline void CalendarRequestedData_serializer::write(SerializerBase& buffer, Ark_CalendarRequestedData value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_year = value.year;
+    valueSerializer.writeNumber(value_year);
+    const auto value_month = value.month;
+    valueSerializer.writeNumber(value_month);
+    const auto value_currentYear = value.currentYear;
+    valueSerializer.writeNumber(value_currentYear);
+    const auto value_currentMonth = value.currentMonth;
+    valueSerializer.writeNumber(value_currentMonth);
+    const auto value_monthState = value.monthState;
+    valueSerializer.writeNumber(value_monthState);
+}
+inline Ark_CalendarRequestedData CalendarRequestedData_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CalendarRequestedData value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.year = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.month = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.currentYear = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.currentMonth = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.monthState = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    return value;
+}
+inline void CalendarSelectedDate_serializer::write(SerializerBase& buffer, Ark_CalendarSelectedDate value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_year = value.year;
+    valueSerializer.writeNumber(value_year);
+    const auto value_month = value.month;
+    valueSerializer.writeNumber(value_month);
+    const auto value_day = value.day;
+    valueSerializer.writeNumber(value_day);
+}
+inline Ark_CalendarSelectedDate CalendarSelectedDate_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CalendarSelectedDate value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.year = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.month = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.day = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    return value;
+}
 inline void CancelButtonSymbolOptions_serializer::write(SerializerBase& buffer, Ark_CancelButtonSymbolOptions value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -73735,6 +74602,36 @@ inline Ark_MessageEvents MessageEvents_serializer::read(DeserializerBase& buffer
     value.data = static_cast<Ark_Object>(valueDeserializer.readObject());
     return value;
 }
+inline void MonthData_serializer::write(SerializerBase& buffer, Ark_MonthData value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_year = value.year;
+    valueSerializer.writeNumber(value_year);
+    const auto value_month = value.month;
+    valueSerializer.writeNumber(value_month);
+    const auto value_data = value.data;
+    valueSerializer.writeInt32(value_data.length);
+    for (int value_data_counter_i = 0; value_data_counter_i < value_data.length; value_data_counter_i++) {
+        const Ark_CalendarDay value_data_element = value_data.array[value_data_counter_i];
+        CalendarDay_serializer::write(valueSerializer, value_data_element);
+    }
+}
+inline Ark_MonthData MonthData_serializer::read(DeserializerBase& buffer)
+{
+    Ark_MonthData value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.year = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.month = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const Ark_Int32 data_buf_length = valueDeserializer.readInt32();
+    Array_CalendarDay data_buf = {};
+    valueDeserializer.resizeArray<std::decay<decltype(data_buf)>::type,
+        std::decay<decltype(*data_buf.array)>::type>(&data_buf, data_buf_length);
+    for (int data_buf_i = 0; data_buf_i < data_buf_length; data_buf_i++) {
+        data_buf.array[data_buf_i] = CalendarDay_serializer::read(valueDeserializer);
+    }
+    value.data = data_buf;
+    return value;
+}
 inline void MotionBlurAnchor_serializer::write(SerializerBase& buffer, Ark_MotionBlurAnchor value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -80966,6 +81863,44 @@ inline Ark_CalendarOptions CalendarOptions_serializer::read(DeserializerBase& bu
     value.disabledDateRange = disabledDateRange_buf;
     return value;
 }
+inline void CalendarRequestedMonths_serializer::write(SerializerBase& buffer, Ark_CalendarRequestedMonths value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_date = value.date;
+    CalendarSelectedDate_serializer::write(valueSerializer, value_date);
+    const auto value_currentData = value.currentData;
+    MonthData_serializer::write(valueSerializer, value_currentData);
+    const auto value_preData = value.preData;
+    MonthData_serializer::write(valueSerializer, value_preData);
+    const auto value_nextData = value.nextData;
+    MonthData_serializer::write(valueSerializer, value_nextData);
+    const auto value_controller = value.controller;
+    Ark_Int32 value_controller_type = INTEROP_RUNTIME_UNDEFINED;
+    value_controller_type = runtimeType(value_controller);
+    valueSerializer.writeInt8(value_controller_type);
+    if ((value_controller_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_controller_value = value_controller.value;
+        CalendarController_serializer::write(valueSerializer, value_controller_value);
+    }
+}
+inline Ark_CalendarRequestedMonths CalendarRequestedMonths_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CalendarRequestedMonths value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.date = CalendarSelectedDate_serializer::read(valueDeserializer);
+    value.currentData = MonthData_serializer::read(valueDeserializer);
+    value.preData = MonthData_serializer::read(valueDeserializer);
+    value.nextData = MonthData_serializer::read(valueDeserializer);
+    const auto controller_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_CalendarController controller_buf = {};
+    controller_buf.tag = controller_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((controller_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        controller_buf.value = static_cast<Ark_CalendarController>(CalendarController_serializer::read(valueDeserializer));
+    }
+    value.controller = controller_buf;
+    return value;
+}
 inline void CanvasRenderer_serializer::write(SerializerBase& buffer, Ark_CanvasRenderer value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -83543,6 +84478,267 @@ inline Ark_ComponentInfo ComponentInfo_serializer::read(DeserializerBase& buffer
     value.transform = transform_buf;
     return value;
 }
+inline void ContentCoverOptions_serializer::write(SerializerBase& buffer, Ark_ContentCoverOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+        }
+        else if (value_backgroundColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
+        }
+        else if (value_backgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
+        }
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+        }
+    }
+    const auto value_onAppear = value.onAppear;
+    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onAppear_type = runtimeType(value_onAppear);
+    valueSerializer.writeInt8(value_onAppear_type);
+    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onAppear_value = value_onAppear.value;
+        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
+    }
+    const auto value_onDisappear = value.onDisappear;
+    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDisappear_type = runtimeType(value_onDisappear);
+    valueSerializer.writeInt8(value_onDisappear_type);
+    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDisappear_value = value_onDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
+    }
+    const auto value_onWillAppear = value.onWillAppear;
+    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillAppear_type = runtimeType(value_onWillAppear);
+    valueSerializer.writeInt8(value_onWillAppear_type);
+    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillAppear_value = value_onWillAppear.value;
+        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    }
+    const auto value_onWillDisappear = value.onWillDisappear;
+    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
+    valueSerializer.writeInt8(value_onWillDisappear_type);
+    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDisappear_value = value_onWillDisappear.value;
+        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    }
+    const auto value_modalTransition = value.modalTransition;
+    Ark_Int32 value_modalTransition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_modalTransition_type = runtimeType(value_modalTransition);
+    valueSerializer.writeInt8(value_modalTransition_type);
+    if ((value_modalTransition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_modalTransition_value = value_modalTransition.value;
+        valueSerializer.writeInt32(static_cast<Ark_ModalTransition>(value_modalTransition_value));
+    }
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
+    }
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    }
+}
+inline Ark_ContentCoverOptions ContentCoverOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_ContentCoverOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        }
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
+    }
+    value.backgroundColor = backgroundColor_buf;
+    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onAppear_buf = {};
+    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onAppear = onAppear_buf;
+    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDisappear_buf = {};
+    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onDisappear = onDisappear_buf;
+    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillAppear_buf = {};
+    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onWillAppear = onWillAppear_buf;
+    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillDisappear_buf = {};
+    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onWillDisappear = onWillDisappear_buf;
+    const auto modalTransition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ModalTransition modalTransition_buf = {};
+    modalTransition_buf.tag = modalTransition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((modalTransition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        modalTransition_buf.value = static_cast<Ark_ModalTransition>(valueDeserializer.readInt32());
+    }
+    value.modalTransition = modalTransition_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_DismissContentCoverAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissContentCoverAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissContentCoverAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissContentCoverAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissContentCoverAction_Void))))};
+    }
+    value.onWillDismiss = onWillDismiss_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    }
+    value.transition = transition_buf;
+    return value;
+}
+inline void ContextMenuAnimationOptions_serializer::write(SerializerBase& buffer, Ark_ContextMenuAnimationOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_scale = value.scale;
+    Ark_Int32 value_scale_type = INTEROP_RUNTIME_UNDEFINED;
+    value_scale_type = runtimeType(value_scale);
+    valueSerializer.writeInt8(value_scale_type);
+    if ((value_scale_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_scale_value = value_scale.value;
+        const auto value_scale_value_0 = value_scale_value.value0;
+        valueSerializer.writeNumber(value_scale_value_0);
+        const auto value_scale_value_1 = value_scale_value.value1;
+        valueSerializer.writeNumber(value_scale_value_1);
+    }
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    }
+    const auto value_hoverScale = value.hoverScale;
+    Ark_Int32 value_hoverScale_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hoverScale_type = runtimeType(value_hoverScale);
+    valueSerializer.writeInt8(value_hoverScale_type);
+    if ((value_hoverScale_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hoverScale_value = value_hoverScale.value;
+        const auto value_hoverScale_value_0 = value_hoverScale_value.value0;
+        valueSerializer.writeNumber(value_hoverScale_value_0);
+        const auto value_hoverScale_value_1 = value_hoverScale_value.value1;
+        valueSerializer.writeNumber(value_hoverScale_value_1);
+    }
+}
+inline Ark_ContextMenuAnimationOptions ContextMenuAnimationOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_ContextMenuAnimationOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto scale_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_AnimationNumberRange scale_buf = {};
+    scale_buf.tag = scale_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((scale_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        Ark_AnimationNumberRange scale_buf_ = {};
+        scale_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        scale_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        scale_buf.value = scale_buf_;
+    }
+    value.scale = scale_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    }
+    value.transition = transition_buf;
+    const auto hoverScale_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_AnimationNumberRange hoverScale_buf = {};
+    hoverScale_buf.tag = hoverScale_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hoverScale_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        Ark_AnimationNumberRange hoverScale_buf_ = {};
+        hoverScale_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        hoverScale_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        hoverScale_buf.value = hoverScale_buf_;
+    }
+    value.hoverScale = hoverScale_buf;
+    return value;
+}
 inline void CopyEvent_serializer::write(SerializerBase& buffer, Ark_CopyEvent value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -83571,6 +84767,513 @@ inline Ark_CopyEvent CopyEvent_serializer::read(DeserializerBase& buffer)
     value.preventDefault = preventDefault_buf;
     return value;
 }
+inline void CurrentDayStyle_serializer::write(SerializerBase& buffer, Ark_CurrentDayStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_dayColor = value.dayColor;
+    Ark_Int32 value_dayColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dayColor_type = runtimeType(value_dayColor);
+    valueSerializer.writeInt8(value_dayColor_type);
+    if ((value_dayColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dayColor_value = value_dayColor.value;
+        Ark_Int32 value_dayColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_dayColor_value_type = value_dayColor_value.selector;
+        if (value_dayColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_dayColor_value_0 = value_dayColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_dayColor_value_0));
+        }
+        else if (value_dayColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_dayColor_value_1 = value_dayColor_value.value1;
+            valueSerializer.writeNumber(value_dayColor_value_1);
+        }
+        else if (value_dayColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_dayColor_value_2 = value_dayColor_value.value2;
+            valueSerializer.writeString(value_dayColor_value_2);
+        }
+        else if (value_dayColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_dayColor_value_3 = value_dayColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_dayColor_value_3);
+        }
+    }
+    const auto value_lunarColor = value.lunarColor;
+    Ark_Int32 value_lunarColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lunarColor_type = runtimeType(value_lunarColor);
+    valueSerializer.writeInt8(value_lunarColor_type);
+    if ((value_lunarColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lunarColor_value = value_lunarColor.value;
+        Ark_Int32 value_lunarColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_lunarColor_value_type = value_lunarColor_value.selector;
+        if (value_lunarColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_lunarColor_value_0 = value_lunarColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_lunarColor_value_0));
+        }
+        else if (value_lunarColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_lunarColor_value_1 = value_lunarColor_value.value1;
+            valueSerializer.writeNumber(value_lunarColor_value_1);
+        }
+        else if (value_lunarColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_lunarColor_value_2 = value_lunarColor_value.value2;
+            valueSerializer.writeString(value_lunarColor_value_2);
+        }
+        else if (value_lunarColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_lunarColor_value_3 = value_lunarColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_lunarColor_value_3);
+        }
+    }
+    const auto value_markLunarColor = value.markLunarColor;
+    Ark_Int32 value_markLunarColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_markLunarColor_type = runtimeType(value_markLunarColor);
+    valueSerializer.writeInt8(value_markLunarColor_type);
+    if ((value_markLunarColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_markLunarColor_value = value_markLunarColor.value;
+        Ark_Int32 value_markLunarColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_markLunarColor_value_type = value_markLunarColor_value.selector;
+        if (value_markLunarColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_markLunarColor_value_0 = value_markLunarColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_markLunarColor_value_0));
+        }
+        else if (value_markLunarColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_markLunarColor_value_1 = value_markLunarColor_value.value1;
+            valueSerializer.writeNumber(value_markLunarColor_value_1);
+        }
+        else if (value_markLunarColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_markLunarColor_value_2 = value_markLunarColor_value.value2;
+            valueSerializer.writeString(value_markLunarColor_value_2);
+        }
+        else if (value_markLunarColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_markLunarColor_value_3 = value_markLunarColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_markLunarColor_value_3);
+        }
+    }
+    const auto value_dayFontSize = value.dayFontSize;
+    Ark_Int32 value_dayFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dayFontSize_type = runtimeType(value_dayFontSize);
+    valueSerializer.writeInt8(value_dayFontSize_type);
+    if ((value_dayFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dayFontSize_value = value_dayFontSize.value;
+        valueSerializer.writeNumber(value_dayFontSize_value);
+    }
+    const auto value_lunarDayFontSize = value.lunarDayFontSize;
+    Ark_Int32 value_lunarDayFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lunarDayFontSize_type = runtimeType(value_lunarDayFontSize);
+    valueSerializer.writeInt8(value_lunarDayFontSize_type);
+    if ((value_lunarDayFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lunarDayFontSize_value = value_lunarDayFontSize.value;
+        valueSerializer.writeNumber(value_lunarDayFontSize_value);
+    }
+    const auto value_dayHeight = value.dayHeight;
+    Ark_Int32 value_dayHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dayHeight_type = runtimeType(value_dayHeight);
+    valueSerializer.writeInt8(value_dayHeight_type);
+    if ((value_dayHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dayHeight_value = value_dayHeight.value;
+        valueSerializer.writeNumber(value_dayHeight_value);
+    }
+    const auto value_dayWidth = value.dayWidth;
+    Ark_Int32 value_dayWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dayWidth_type = runtimeType(value_dayWidth);
+    valueSerializer.writeInt8(value_dayWidth_type);
+    if ((value_dayWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dayWidth_value = value_dayWidth.value;
+        valueSerializer.writeNumber(value_dayWidth_value);
+    }
+    const auto value_gregorianCalendarHeight = value.gregorianCalendarHeight;
+    Ark_Int32 value_gregorianCalendarHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_gregorianCalendarHeight_type = runtimeType(value_gregorianCalendarHeight);
+    valueSerializer.writeInt8(value_gregorianCalendarHeight_type);
+    if ((value_gregorianCalendarHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_gregorianCalendarHeight_value = value_gregorianCalendarHeight.value;
+        valueSerializer.writeNumber(value_gregorianCalendarHeight_value);
+    }
+    const auto value_dayYAxisOffset = value.dayYAxisOffset;
+    Ark_Int32 value_dayYAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dayYAxisOffset_type = runtimeType(value_dayYAxisOffset);
+    valueSerializer.writeInt8(value_dayYAxisOffset_type);
+    if ((value_dayYAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dayYAxisOffset_value = value_dayYAxisOffset.value;
+        valueSerializer.writeNumber(value_dayYAxisOffset_value);
+    }
+    const auto value_lunarDayYAxisOffset = value.lunarDayYAxisOffset;
+    Ark_Int32 value_lunarDayYAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lunarDayYAxisOffset_type = runtimeType(value_lunarDayYAxisOffset);
+    valueSerializer.writeInt8(value_lunarDayYAxisOffset_type);
+    if ((value_lunarDayYAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lunarDayYAxisOffset_value = value_lunarDayYAxisOffset.value;
+        valueSerializer.writeNumber(value_lunarDayYAxisOffset_value);
+    }
+    const auto value_underscoreXAxisOffset = value.underscoreXAxisOffset;
+    Ark_Int32 value_underscoreXAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_underscoreXAxisOffset_type = runtimeType(value_underscoreXAxisOffset);
+    valueSerializer.writeInt8(value_underscoreXAxisOffset_type);
+    if ((value_underscoreXAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_underscoreXAxisOffset_value = value_underscoreXAxisOffset.value;
+        valueSerializer.writeNumber(value_underscoreXAxisOffset_value);
+    }
+    const auto value_underscoreYAxisOffset = value.underscoreYAxisOffset;
+    Ark_Int32 value_underscoreYAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_underscoreYAxisOffset_type = runtimeType(value_underscoreYAxisOffset);
+    valueSerializer.writeInt8(value_underscoreYAxisOffset_type);
+    if ((value_underscoreYAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_underscoreYAxisOffset_value = value_underscoreYAxisOffset.value;
+        valueSerializer.writeNumber(value_underscoreYAxisOffset_value);
+    }
+    const auto value_scheduleMarkerXAxisOffset = value.scheduleMarkerXAxisOffset;
+    Ark_Int32 value_scheduleMarkerXAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_scheduleMarkerXAxisOffset_type = runtimeType(value_scheduleMarkerXAxisOffset);
+    valueSerializer.writeInt8(value_scheduleMarkerXAxisOffset_type);
+    if ((value_scheduleMarkerXAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_scheduleMarkerXAxisOffset_value = value_scheduleMarkerXAxisOffset.value;
+        valueSerializer.writeNumber(value_scheduleMarkerXAxisOffset_value);
+    }
+    const auto value_scheduleMarkerYAxisOffset = value.scheduleMarkerYAxisOffset;
+    Ark_Int32 value_scheduleMarkerYAxisOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_scheduleMarkerYAxisOffset_type = runtimeType(value_scheduleMarkerYAxisOffset);
+    valueSerializer.writeInt8(value_scheduleMarkerYAxisOffset_type);
+    if ((value_scheduleMarkerYAxisOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_scheduleMarkerYAxisOffset_value = value_scheduleMarkerYAxisOffset.value;
+        valueSerializer.writeNumber(value_scheduleMarkerYAxisOffset_value);
+    }
+    const auto value_colSpace = value.colSpace;
+    Ark_Int32 value_colSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_colSpace_type = runtimeType(value_colSpace);
+    valueSerializer.writeInt8(value_colSpace_type);
+    if ((value_colSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_colSpace_value = value_colSpace.value;
+        valueSerializer.writeNumber(value_colSpace_value);
+    }
+    const auto value_dailyFiveRowSpace = value.dailyFiveRowSpace;
+    Ark_Int32 value_dailyFiveRowSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dailyFiveRowSpace_type = runtimeType(value_dailyFiveRowSpace);
+    valueSerializer.writeInt8(value_dailyFiveRowSpace_type);
+    if ((value_dailyFiveRowSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dailyFiveRowSpace_value = value_dailyFiveRowSpace.value;
+        valueSerializer.writeNumber(value_dailyFiveRowSpace_value);
+    }
+    const auto value_dailySixRowSpace = value.dailySixRowSpace;
+    Ark_Int32 value_dailySixRowSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dailySixRowSpace_type = runtimeType(value_dailySixRowSpace);
+    valueSerializer.writeInt8(value_dailySixRowSpace_type);
+    if ((value_dailySixRowSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dailySixRowSpace_value = value_dailySixRowSpace.value;
+        valueSerializer.writeNumber(value_dailySixRowSpace_value);
+    }
+    const auto value_lunarHeight = value.lunarHeight;
+    Ark_Int32 value_lunarHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lunarHeight_type = runtimeType(value_lunarHeight);
+    valueSerializer.writeInt8(value_lunarHeight_type);
+    if ((value_lunarHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lunarHeight_value = value_lunarHeight.value;
+        valueSerializer.writeNumber(value_lunarHeight_value);
+    }
+    const auto value_underscoreWidth = value.underscoreWidth;
+    Ark_Int32 value_underscoreWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_underscoreWidth_type = runtimeType(value_underscoreWidth);
+    valueSerializer.writeInt8(value_underscoreWidth_type);
+    if ((value_underscoreWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_underscoreWidth_value = value_underscoreWidth.value;
+        valueSerializer.writeNumber(value_underscoreWidth_value);
+    }
+    const auto value_underscoreLength = value.underscoreLength;
+    Ark_Int32 value_underscoreLength_type = INTEROP_RUNTIME_UNDEFINED;
+    value_underscoreLength_type = runtimeType(value_underscoreLength);
+    valueSerializer.writeInt8(value_underscoreLength_type);
+    if ((value_underscoreLength_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_underscoreLength_value = value_underscoreLength.value;
+        valueSerializer.writeNumber(value_underscoreLength_value);
+    }
+    const auto value_scheduleMarkerRadius = value.scheduleMarkerRadius;
+    Ark_Int32 value_scheduleMarkerRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_scheduleMarkerRadius_type = runtimeType(value_scheduleMarkerRadius);
+    valueSerializer.writeInt8(value_scheduleMarkerRadius_type);
+    if ((value_scheduleMarkerRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_scheduleMarkerRadius_value = value_scheduleMarkerRadius.value;
+        valueSerializer.writeNumber(value_scheduleMarkerRadius_value);
+    }
+    const auto value_boundaryRowOffset = value.boundaryRowOffset;
+    Ark_Int32 value_boundaryRowOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_boundaryRowOffset_type = runtimeType(value_boundaryRowOffset);
+    valueSerializer.writeInt8(value_boundaryRowOffset_type);
+    if ((value_boundaryRowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_boundaryRowOffset_value = value_boundaryRowOffset.value;
+        valueSerializer.writeNumber(value_boundaryRowOffset_value);
+    }
+    const auto value_boundaryColOffset = value.boundaryColOffset;
+    Ark_Int32 value_boundaryColOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_boundaryColOffset_type = runtimeType(value_boundaryColOffset);
+    valueSerializer.writeInt8(value_boundaryColOffset_type);
+    if ((value_boundaryColOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_boundaryColOffset_value = value_boundaryColOffset.value;
+        valueSerializer.writeNumber(value_boundaryColOffset_value);
+    }
+}
+inline Ark_CurrentDayStyle CurrentDayStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CurrentDayStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto dayColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor dayColor_buf = {};
+    dayColor_buf.tag = dayColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dayColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 dayColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor dayColor_buf_ = {};
+        dayColor_buf_.selector = dayColor_buf__selector;
+        if (dayColor_buf__selector == 0) {
+            dayColor_buf_.selector = 0;
+            dayColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (dayColor_buf__selector == 1) {
+            dayColor_buf_.selector = 1;
+            dayColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (dayColor_buf__selector == 2) {
+            dayColor_buf_.selector = 2;
+            dayColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (dayColor_buf__selector == 3) {
+            dayColor_buf_.selector = 3;
+            dayColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for dayColor_buf_ has to be chosen through deserialisation.");
+        }
+        dayColor_buf.value = static_cast<Ark_ResourceColor>(dayColor_buf_);
+    }
+    value.dayColor = dayColor_buf;
+    const auto lunarColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor lunarColor_buf = {};
+    lunarColor_buf.tag = lunarColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lunarColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 lunarColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor lunarColor_buf_ = {};
+        lunarColor_buf_.selector = lunarColor_buf__selector;
+        if (lunarColor_buf__selector == 0) {
+            lunarColor_buf_.selector = 0;
+            lunarColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (lunarColor_buf__selector == 1) {
+            lunarColor_buf_.selector = 1;
+            lunarColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (lunarColor_buf__selector == 2) {
+            lunarColor_buf_.selector = 2;
+            lunarColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (lunarColor_buf__selector == 3) {
+            lunarColor_buf_.selector = 3;
+            lunarColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for lunarColor_buf_ has to be chosen through deserialisation.");
+        }
+        lunarColor_buf.value = static_cast<Ark_ResourceColor>(lunarColor_buf_);
+    }
+    value.lunarColor = lunarColor_buf;
+    const auto markLunarColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor markLunarColor_buf = {};
+    markLunarColor_buf.tag = markLunarColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((markLunarColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 markLunarColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor markLunarColor_buf_ = {};
+        markLunarColor_buf_.selector = markLunarColor_buf__selector;
+        if (markLunarColor_buf__selector == 0) {
+            markLunarColor_buf_.selector = 0;
+            markLunarColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (markLunarColor_buf__selector == 1) {
+            markLunarColor_buf_.selector = 1;
+            markLunarColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (markLunarColor_buf__selector == 2) {
+            markLunarColor_buf_.selector = 2;
+            markLunarColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (markLunarColor_buf__selector == 3) {
+            markLunarColor_buf_.selector = 3;
+            markLunarColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for markLunarColor_buf_ has to be chosen through deserialisation.");
+        }
+        markLunarColor_buf.value = static_cast<Ark_ResourceColor>(markLunarColor_buf_);
+    }
+    value.markLunarColor = markLunarColor_buf;
+    const auto dayFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dayFontSize_buf = {};
+    dayFontSize_buf.tag = dayFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dayFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dayFontSize_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dayFontSize = dayFontSize_buf;
+    const auto lunarDayFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number lunarDayFontSize_buf = {};
+    lunarDayFontSize_buf.tag = lunarDayFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lunarDayFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        lunarDayFontSize_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.lunarDayFontSize = lunarDayFontSize_buf;
+    const auto dayHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dayHeight_buf = {};
+    dayHeight_buf.tag = dayHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dayHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dayHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dayHeight = dayHeight_buf;
+    const auto dayWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dayWidth_buf = {};
+    dayWidth_buf.tag = dayWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dayWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dayWidth_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dayWidth = dayWidth_buf;
+    const auto gregorianCalendarHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number gregorianCalendarHeight_buf = {};
+    gregorianCalendarHeight_buf.tag = gregorianCalendarHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((gregorianCalendarHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        gregorianCalendarHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.gregorianCalendarHeight = gregorianCalendarHeight_buf;
+    const auto dayYAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dayYAxisOffset_buf = {};
+    dayYAxisOffset_buf.tag = dayYAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dayYAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dayYAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dayYAxisOffset = dayYAxisOffset_buf;
+    const auto lunarDayYAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number lunarDayYAxisOffset_buf = {};
+    lunarDayYAxisOffset_buf.tag = lunarDayYAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lunarDayYAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        lunarDayYAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.lunarDayYAxisOffset = lunarDayYAxisOffset_buf;
+    const auto underscoreXAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number underscoreXAxisOffset_buf = {};
+    underscoreXAxisOffset_buf.tag = underscoreXAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((underscoreXAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        underscoreXAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.underscoreXAxisOffset = underscoreXAxisOffset_buf;
+    const auto underscoreYAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number underscoreYAxisOffset_buf = {};
+    underscoreYAxisOffset_buf.tag = underscoreYAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((underscoreYAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        underscoreYAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.underscoreYAxisOffset = underscoreYAxisOffset_buf;
+    const auto scheduleMarkerXAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number scheduleMarkerXAxisOffset_buf = {};
+    scheduleMarkerXAxisOffset_buf.tag = scheduleMarkerXAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((scheduleMarkerXAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        scheduleMarkerXAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.scheduleMarkerXAxisOffset = scheduleMarkerXAxisOffset_buf;
+    const auto scheduleMarkerYAxisOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number scheduleMarkerYAxisOffset_buf = {};
+    scheduleMarkerYAxisOffset_buf.tag = scheduleMarkerYAxisOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((scheduleMarkerYAxisOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        scheduleMarkerYAxisOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.scheduleMarkerYAxisOffset = scheduleMarkerYAxisOffset_buf;
+    const auto colSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number colSpace_buf = {};
+    colSpace_buf.tag = colSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((colSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        colSpace_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.colSpace = colSpace_buf;
+    const auto dailyFiveRowSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dailyFiveRowSpace_buf = {};
+    dailyFiveRowSpace_buf.tag = dailyFiveRowSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dailyFiveRowSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dailyFiveRowSpace_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dailyFiveRowSpace = dailyFiveRowSpace_buf;
+    const auto dailySixRowSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number dailySixRowSpace_buf = {};
+    dailySixRowSpace_buf.tag = dailySixRowSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dailySixRowSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        dailySixRowSpace_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.dailySixRowSpace = dailySixRowSpace_buf;
+    const auto lunarHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number lunarHeight_buf = {};
+    lunarHeight_buf.tag = lunarHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lunarHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        lunarHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.lunarHeight = lunarHeight_buf;
+    const auto underscoreWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number underscoreWidth_buf = {};
+    underscoreWidth_buf.tag = underscoreWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((underscoreWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        underscoreWidth_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.underscoreWidth = underscoreWidth_buf;
+    const auto underscoreLength_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number underscoreLength_buf = {};
+    underscoreLength_buf.tag = underscoreLength_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((underscoreLength_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        underscoreLength_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.underscoreLength = underscoreLength_buf;
+    const auto scheduleMarkerRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number scheduleMarkerRadius_buf = {};
+    scheduleMarkerRadius_buf.tag = scheduleMarkerRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((scheduleMarkerRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        scheduleMarkerRadius_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.scheduleMarkerRadius = scheduleMarkerRadius_buf;
+    const auto boundaryRowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number boundaryRowOffset_buf = {};
+    boundaryRowOffset_buf.tag = boundaryRowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((boundaryRowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        boundaryRowOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.boundaryRowOffset = boundaryRowOffset_buf;
+    const auto boundaryColOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number boundaryColOffset_buf = {};
+    boundaryColOffset_buf.tag = boundaryColOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((boundaryColOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        boundaryColOffset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.boundaryColOffset = boundaryColOffset_buf;
+    return value;
+}
 inline void CutEvent_serializer::write(SerializerBase& buffer, Ark_CutEvent value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -87997,6 +89700,252 @@ inline Ark_NavigationTransitionProxy NavigationTransitionProxy_serializer::read(
     Ark_NativePointer ptr = valueDeserializer.readPointer();
     return static_cast<Ark_NavigationTransitionProxy>(ptr);
 }
+inline void NonCurrentDayStyle_serializer::write(SerializerBase& buffer, Ark_NonCurrentDayStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_nonCurrentMonthDayColor = value.nonCurrentMonthDayColor;
+    Ark_Int32 value_nonCurrentMonthDayColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_nonCurrentMonthDayColor_type = runtimeType(value_nonCurrentMonthDayColor);
+    valueSerializer.writeInt8(value_nonCurrentMonthDayColor_type);
+    if ((value_nonCurrentMonthDayColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_nonCurrentMonthDayColor_value = value_nonCurrentMonthDayColor.value;
+        Ark_Int32 value_nonCurrentMonthDayColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_nonCurrentMonthDayColor_value_type = value_nonCurrentMonthDayColor_value.selector;
+        if (value_nonCurrentMonthDayColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_nonCurrentMonthDayColor_value_0 = value_nonCurrentMonthDayColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_nonCurrentMonthDayColor_value_0));
+        }
+        else if (value_nonCurrentMonthDayColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_nonCurrentMonthDayColor_value_1 = value_nonCurrentMonthDayColor_value.value1;
+            valueSerializer.writeNumber(value_nonCurrentMonthDayColor_value_1);
+        }
+        else if (value_nonCurrentMonthDayColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_nonCurrentMonthDayColor_value_2 = value_nonCurrentMonthDayColor_value.value2;
+            valueSerializer.writeString(value_nonCurrentMonthDayColor_value_2);
+        }
+        else if (value_nonCurrentMonthDayColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_nonCurrentMonthDayColor_value_3 = value_nonCurrentMonthDayColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_nonCurrentMonthDayColor_value_3);
+        }
+    }
+    const auto value_nonCurrentMonthLunarColor = value.nonCurrentMonthLunarColor;
+    Ark_Int32 value_nonCurrentMonthLunarColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_nonCurrentMonthLunarColor_type = runtimeType(value_nonCurrentMonthLunarColor);
+    valueSerializer.writeInt8(value_nonCurrentMonthLunarColor_type);
+    if ((value_nonCurrentMonthLunarColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_nonCurrentMonthLunarColor_value = value_nonCurrentMonthLunarColor.value;
+        Ark_Int32 value_nonCurrentMonthLunarColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_nonCurrentMonthLunarColor_value_type = value_nonCurrentMonthLunarColor_value.selector;
+        if (value_nonCurrentMonthLunarColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_nonCurrentMonthLunarColor_value_0 = value_nonCurrentMonthLunarColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_nonCurrentMonthLunarColor_value_0));
+        }
+        else if (value_nonCurrentMonthLunarColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_nonCurrentMonthLunarColor_value_1 = value_nonCurrentMonthLunarColor_value.value1;
+            valueSerializer.writeNumber(value_nonCurrentMonthLunarColor_value_1);
+        }
+        else if (value_nonCurrentMonthLunarColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_nonCurrentMonthLunarColor_value_2 = value_nonCurrentMonthLunarColor_value.value2;
+            valueSerializer.writeString(value_nonCurrentMonthLunarColor_value_2);
+        }
+        else if (value_nonCurrentMonthLunarColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_nonCurrentMonthLunarColor_value_3 = value_nonCurrentMonthLunarColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_nonCurrentMonthLunarColor_value_3);
+        }
+    }
+    const auto value_nonCurrentMonthWorkDayMarkColor = value.nonCurrentMonthWorkDayMarkColor;
+    Ark_Int32 value_nonCurrentMonthWorkDayMarkColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_nonCurrentMonthWorkDayMarkColor_type = runtimeType(value_nonCurrentMonthWorkDayMarkColor);
+    valueSerializer.writeInt8(value_nonCurrentMonthWorkDayMarkColor_type);
+    if ((value_nonCurrentMonthWorkDayMarkColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_nonCurrentMonthWorkDayMarkColor_value = value_nonCurrentMonthWorkDayMarkColor.value;
+        Ark_Int32 value_nonCurrentMonthWorkDayMarkColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_nonCurrentMonthWorkDayMarkColor_value_type = value_nonCurrentMonthWorkDayMarkColor_value.selector;
+        if (value_nonCurrentMonthWorkDayMarkColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_nonCurrentMonthWorkDayMarkColor_value_0 = value_nonCurrentMonthWorkDayMarkColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_nonCurrentMonthWorkDayMarkColor_value_0));
+        }
+        else if (value_nonCurrentMonthWorkDayMarkColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_nonCurrentMonthWorkDayMarkColor_value_1 = value_nonCurrentMonthWorkDayMarkColor_value.value1;
+            valueSerializer.writeNumber(value_nonCurrentMonthWorkDayMarkColor_value_1);
+        }
+        else if (value_nonCurrentMonthWorkDayMarkColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_nonCurrentMonthWorkDayMarkColor_value_2 = value_nonCurrentMonthWorkDayMarkColor_value.value2;
+            valueSerializer.writeString(value_nonCurrentMonthWorkDayMarkColor_value_2);
+        }
+        else if (value_nonCurrentMonthWorkDayMarkColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_nonCurrentMonthWorkDayMarkColor_value_3 = value_nonCurrentMonthWorkDayMarkColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_nonCurrentMonthWorkDayMarkColor_value_3);
+        }
+    }
+    const auto value_nonCurrentMonthOffDayMarkColor = value.nonCurrentMonthOffDayMarkColor;
+    Ark_Int32 value_nonCurrentMonthOffDayMarkColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_nonCurrentMonthOffDayMarkColor_type = runtimeType(value_nonCurrentMonthOffDayMarkColor);
+    valueSerializer.writeInt8(value_nonCurrentMonthOffDayMarkColor_type);
+    if ((value_nonCurrentMonthOffDayMarkColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_nonCurrentMonthOffDayMarkColor_value = value_nonCurrentMonthOffDayMarkColor.value;
+        Ark_Int32 value_nonCurrentMonthOffDayMarkColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_nonCurrentMonthOffDayMarkColor_value_type = value_nonCurrentMonthOffDayMarkColor_value.selector;
+        if (value_nonCurrentMonthOffDayMarkColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_nonCurrentMonthOffDayMarkColor_value_0 = value_nonCurrentMonthOffDayMarkColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_nonCurrentMonthOffDayMarkColor_value_0));
+        }
+        else if (value_nonCurrentMonthOffDayMarkColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_nonCurrentMonthOffDayMarkColor_value_1 = value_nonCurrentMonthOffDayMarkColor_value.value1;
+            valueSerializer.writeNumber(value_nonCurrentMonthOffDayMarkColor_value_1);
+        }
+        else if (value_nonCurrentMonthOffDayMarkColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_nonCurrentMonthOffDayMarkColor_value_2 = value_nonCurrentMonthOffDayMarkColor_value.value2;
+            valueSerializer.writeString(value_nonCurrentMonthOffDayMarkColor_value_2);
+        }
+        else if (value_nonCurrentMonthOffDayMarkColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_nonCurrentMonthOffDayMarkColor_value_3 = value_nonCurrentMonthOffDayMarkColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_nonCurrentMonthOffDayMarkColor_value_3);
+        }
+    }
+}
+inline Ark_NonCurrentDayStyle NonCurrentDayStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_NonCurrentDayStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto nonCurrentMonthDayColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor nonCurrentMonthDayColor_buf = {};
+    nonCurrentMonthDayColor_buf.tag = nonCurrentMonthDayColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((nonCurrentMonthDayColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 nonCurrentMonthDayColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor nonCurrentMonthDayColor_buf_ = {};
+        nonCurrentMonthDayColor_buf_.selector = nonCurrentMonthDayColor_buf__selector;
+        if (nonCurrentMonthDayColor_buf__selector == 0) {
+            nonCurrentMonthDayColor_buf_.selector = 0;
+            nonCurrentMonthDayColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (nonCurrentMonthDayColor_buf__selector == 1) {
+            nonCurrentMonthDayColor_buf_.selector = 1;
+            nonCurrentMonthDayColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (nonCurrentMonthDayColor_buf__selector == 2) {
+            nonCurrentMonthDayColor_buf_.selector = 2;
+            nonCurrentMonthDayColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (nonCurrentMonthDayColor_buf__selector == 3) {
+            nonCurrentMonthDayColor_buf_.selector = 3;
+            nonCurrentMonthDayColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for nonCurrentMonthDayColor_buf_ has to be chosen through deserialisation.");
+        }
+        nonCurrentMonthDayColor_buf.value = static_cast<Ark_ResourceColor>(nonCurrentMonthDayColor_buf_);
+    }
+    value.nonCurrentMonthDayColor = nonCurrentMonthDayColor_buf;
+    const auto nonCurrentMonthLunarColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor nonCurrentMonthLunarColor_buf = {};
+    nonCurrentMonthLunarColor_buf.tag = nonCurrentMonthLunarColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((nonCurrentMonthLunarColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 nonCurrentMonthLunarColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor nonCurrentMonthLunarColor_buf_ = {};
+        nonCurrentMonthLunarColor_buf_.selector = nonCurrentMonthLunarColor_buf__selector;
+        if (nonCurrentMonthLunarColor_buf__selector == 0) {
+            nonCurrentMonthLunarColor_buf_.selector = 0;
+            nonCurrentMonthLunarColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (nonCurrentMonthLunarColor_buf__selector == 1) {
+            nonCurrentMonthLunarColor_buf_.selector = 1;
+            nonCurrentMonthLunarColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (nonCurrentMonthLunarColor_buf__selector == 2) {
+            nonCurrentMonthLunarColor_buf_.selector = 2;
+            nonCurrentMonthLunarColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (nonCurrentMonthLunarColor_buf__selector == 3) {
+            nonCurrentMonthLunarColor_buf_.selector = 3;
+            nonCurrentMonthLunarColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for nonCurrentMonthLunarColor_buf_ has to be chosen through deserialisation.");
+        }
+        nonCurrentMonthLunarColor_buf.value = static_cast<Ark_ResourceColor>(nonCurrentMonthLunarColor_buf_);
+    }
+    value.nonCurrentMonthLunarColor = nonCurrentMonthLunarColor_buf;
+    const auto nonCurrentMonthWorkDayMarkColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor nonCurrentMonthWorkDayMarkColor_buf = {};
+    nonCurrentMonthWorkDayMarkColor_buf.tag = nonCurrentMonthWorkDayMarkColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((nonCurrentMonthWorkDayMarkColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 nonCurrentMonthWorkDayMarkColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor nonCurrentMonthWorkDayMarkColor_buf_ = {};
+        nonCurrentMonthWorkDayMarkColor_buf_.selector = nonCurrentMonthWorkDayMarkColor_buf__selector;
+        if (nonCurrentMonthWorkDayMarkColor_buf__selector == 0) {
+            nonCurrentMonthWorkDayMarkColor_buf_.selector = 0;
+            nonCurrentMonthWorkDayMarkColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (nonCurrentMonthWorkDayMarkColor_buf__selector == 1) {
+            nonCurrentMonthWorkDayMarkColor_buf_.selector = 1;
+            nonCurrentMonthWorkDayMarkColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (nonCurrentMonthWorkDayMarkColor_buf__selector == 2) {
+            nonCurrentMonthWorkDayMarkColor_buf_.selector = 2;
+            nonCurrentMonthWorkDayMarkColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (nonCurrentMonthWorkDayMarkColor_buf__selector == 3) {
+            nonCurrentMonthWorkDayMarkColor_buf_.selector = 3;
+            nonCurrentMonthWorkDayMarkColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for nonCurrentMonthWorkDayMarkColor_buf_ has to be chosen through deserialisation.");
+        }
+        nonCurrentMonthWorkDayMarkColor_buf.value = static_cast<Ark_ResourceColor>(nonCurrentMonthWorkDayMarkColor_buf_);
+    }
+    value.nonCurrentMonthWorkDayMarkColor = nonCurrentMonthWorkDayMarkColor_buf;
+    const auto nonCurrentMonthOffDayMarkColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor nonCurrentMonthOffDayMarkColor_buf = {};
+    nonCurrentMonthOffDayMarkColor_buf.tag = nonCurrentMonthOffDayMarkColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((nonCurrentMonthOffDayMarkColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 nonCurrentMonthOffDayMarkColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor nonCurrentMonthOffDayMarkColor_buf_ = {};
+        nonCurrentMonthOffDayMarkColor_buf_.selector = nonCurrentMonthOffDayMarkColor_buf__selector;
+        if (nonCurrentMonthOffDayMarkColor_buf__selector == 0) {
+            nonCurrentMonthOffDayMarkColor_buf_.selector = 0;
+            nonCurrentMonthOffDayMarkColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (nonCurrentMonthOffDayMarkColor_buf__selector == 1) {
+            nonCurrentMonthOffDayMarkColor_buf_.selector = 1;
+            nonCurrentMonthOffDayMarkColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (nonCurrentMonthOffDayMarkColor_buf__selector == 2) {
+            nonCurrentMonthOffDayMarkColor_buf_.selector = 2;
+            nonCurrentMonthOffDayMarkColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (nonCurrentMonthOffDayMarkColor_buf__selector == 3) {
+            nonCurrentMonthOffDayMarkColor_buf_.selector = 3;
+            nonCurrentMonthOffDayMarkColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for nonCurrentMonthOffDayMarkColor_buf_ has to be chosen through deserialisation.");
+        }
+        nonCurrentMonthOffDayMarkColor_buf.value = static_cast<Ark_ResourceColor>(nonCurrentMonthOffDayMarkColor_buf_);
+    }
+    value.nonCurrentMonthOffDayMarkColor = nonCurrentMonthOffDayMarkColor_buf;
+    return value;
+}
 inline void OffscreenCanvasRenderingContext2D_serializer::write(SerializerBase& buffer, Ark_OffscreenCanvasRenderingContext2D value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -92034,6 +93983,209 @@ inline Ark_TextStyleInterface TextStyleInterface_serializer::read(DeserializerBa
     value.fontStyle = fontStyle_buf;
     return value;
 }
+inline void TodayStyle_serializer::write(SerializerBase& buffer, Ark_TodayStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_focusedDayColor = value.focusedDayColor;
+    Ark_Int32 value_focusedDayColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusedDayColor_type = runtimeType(value_focusedDayColor);
+    valueSerializer.writeInt8(value_focusedDayColor_type);
+    if ((value_focusedDayColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusedDayColor_value = value_focusedDayColor.value;
+        Ark_Int32 value_focusedDayColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_focusedDayColor_value_type = value_focusedDayColor_value.selector;
+        if (value_focusedDayColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_focusedDayColor_value_0 = value_focusedDayColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_focusedDayColor_value_0));
+        }
+        else if (value_focusedDayColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_focusedDayColor_value_1 = value_focusedDayColor_value.value1;
+            valueSerializer.writeNumber(value_focusedDayColor_value_1);
+        }
+        else if (value_focusedDayColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_focusedDayColor_value_2 = value_focusedDayColor_value.value2;
+            valueSerializer.writeString(value_focusedDayColor_value_2);
+        }
+        else if (value_focusedDayColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_focusedDayColor_value_3 = value_focusedDayColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_focusedDayColor_value_3);
+        }
+    }
+    const auto value_focusedLunarColor = value.focusedLunarColor;
+    Ark_Int32 value_focusedLunarColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusedLunarColor_type = runtimeType(value_focusedLunarColor);
+    valueSerializer.writeInt8(value_focusedLunarColor_type);
+    if ((value_focusedLunarColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusedLunarColor_value = value_focusedLunarColor.value;
+        Ark_Int32 value_focusedLunarColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_focusedLunarColor_value_type = value_focusedLunarColor_value.selector;
+        if (value_focusedLunarColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_focusedLunarColor_value_0 = value_focusedLunarColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_focusedLunarColor_value_0));
+        }
+        else if (value_focusedLunarColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_focusedLunarColor_value_1 = value_focusedLunarColor_value.value1;
+            valueSerializer.writeNumber(value_focusedLunarColor_value_1);
+        }
+        else if (value_focusedLunarColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_focusedLunarColor_value_2 = value_focusedLunarColor_value.value2;
+            valueSerializer.writeString(value_focusedLunarColor_value_2);
+        }
+        else if (value_focusedLunarColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_focusedLunarColor_value_3 = value_focusedLunarColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_focusedLunarColor_value_3);
+        }
+    }
+    const auto value_focusedAreaBackgroundColor = value.focusedAreaBackgroundColor;
+    Ark_Int32 value_focusedAreaBackgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusedAreaBackgroundColor_type = runtimeType(value_focusedAreaBackgroundColor);
+    valueSerializer.writeInt8(value_focusedAreaBackgroundColor_type);
+    if ((value_focusedAreaBackgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusedAreaBackgroundColor_value = value_focusedAreaBackgroundColor.value;
+        Ark_Int32 value_focusedAreaBackgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_focusedAreaBackgroundColor_value_type = value_focusedAreaBackgroundColor_value.selector;
+        if (value_focusedAreaBackgroundColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_focusedAreaBackgroundColor_value_0 = value_focusedAreaBackgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_focusedAreaBackgroundColor_value_0));
+        }
+        else if (value_focusedAreaBackgroundColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_focusedAreaBackgroundColor_value_1 = value_focusedAreaBackgroundColor_value.value1;
+            valueSerializer.writeNumber(value_focusedAreaBackgroundColor_value_1);
+        }
+        else if (value_focusedAreaBackgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_focusedAreaBackgroundColor_value_2 = value_focusedAreaBackgroundColor_value.value2;
+            valueSerializer.writeString(value_focusedAreaBackgroundColor_value_2);
+        }
+        else if (value_focusedAreaBackgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_focusedAreaBackgroundColor_value_3 = value_focusedAreaBackgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_focusedAreaBackgroundColor_value_3);
+        }
+    }
+    const auto value_focusedAreaRadius = value.focusedAreaRadius;
+    Ark_Int32 value_focusedAreaRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusedAreaRadius_type = runtimeType(value_focusedAreaRadius);
+    valueSerializer.writeInt8(value_focusedAreaRadius_type);
+    if ((value_focusedAreaRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusedAreaRadius_value = value_focusedAreaRadius.value;
+        valueSerializer.writeNumber(value_focusedAreaRadius_value);
+    }
+}
+inline Ark_TodayStyle TodayStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_TodayStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto focusedDayColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor focusedDayColor_buf = {};
+    focusedDayColor_buf.tag = focusedDayColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusedDayColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 focusedDayColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor focusedDayColor_buf_ = {};
+        focusedDayColor_buf_.selector = focusedDayColor_buf__selector;
+        if (focusedDayColor_buf__selector == 0) {
+            focusedDayColor_buf_.selector = 0;
+            focusedDayColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (focusedDayColor_buf__selector == 1) {
+            focusedDayColor_buf_.selector = 1;
+            focusedDayColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (focusedDayColor_buf__selector == 2) {
+            focusedDayColor_buf_.selector = 2;
+            focusedDayColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (focusedDayColor_buf__selector == 3) {
+            focusedDayColor_buf_.selector = 3;
+            focusedDayColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for focusedDayColor_buf_ has to be chosen through deserialisation.");
+        }
+        focusedDayColor_buf.value = static_cast<Ark_ResourceColor>(focusedDayColor_buf_);
+    }
+    value.focusedDayColor = focusedDayColor_buf;
+    const auto focusedLunarColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor focusedLunarColor_buf = {};
+    focusedLunarColor_buf.tag = focusedLunarColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusedLunarColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 focusedLunarColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor focusedLunarColor_buf_ = {};
+        focusedLunarColor_buf_.selector = focusedLunarColor_buf__selector;
+        if (focusedLunarColor_buf__selector == 0) {
+            focusedLunarColor_buf_.selector = 0;
+            focusedLunarColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (focusedLunarColor_buf__selector == 1) {
+            focusedLunarColor_buf_.selector = 1;
+            focusedLunarColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (focusedLunarColor_buf__selector == 2) {
+            focusedLunarColor_buf_.selector = 2;
+            focusedLunarColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (focusedLunarColor_buf__selector == 3) {
+            focusedLunarColor_buf_.selector = 3;
+            focusedLunarColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for focusedLunarColor_buf_ has to be chosen through deserialisation.");
+        }
+        focusedLunarColor_buf.value = static_cast<Ark_ResourceColor>(focusedLunarColor_buf_);
+    }
+    value.focusedLunarColor = focusedLunarColor_buf;
+    const auto focusedAreaBackgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor focusedAreaBackgroundColor_buf = {};
+    focusedAreaBackgroundColor_buf.tag = focusedAreaBackgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusedAreaBackgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 focusedAreaBackgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor focusedAreaBackgroundColor_buf_ = {};
+        focusedAreaBackgroundColor_buf_.selector = focusedAreaBackgroundColor_buf__selector;
+        if (focusedAreaBackgroundColor_buf__selector == 0) {
+            focusedAreaBackgroundColor_buf_.selector = 0;
+            focusedAreaBackgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (focusedAreaBackgroundColor_buf__selector == 1) {
+            focusedAreaBackgroundColor_buf_.selector = 1;
+            focusedAreaBackgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (focusedAreaBackgroundColor_buf__selector == 2) {
+            focusedAreaBackgroundColor_buf_.selector = 2;
+            focusedAreaBackgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (focusedAreaBackgroundColor_buf__selector == 3) {
+            focusedAreaBackgroundColor_buf_.selector = 3;
+            focusedAreaBackgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for focusedAreaBackgroundColor_buf_ has to be chosen through deserialisation.");
+        }
+        focusedAreaBackgroundColor_buf.value = static_cast<Ark_ResourceColor>(focusedAreaBackgroundColor_buf_);
+    }
+    value.focusedAreaBackgroundColor = focusedAreaBackgroundColor_buf;
+    const auto focusedAreaRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number focusedAreaRadius_buf = {};
+    focusedAreaRadius_buf.tag = focusedAreaRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusedAreaRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        focusedAreaRadius_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.focusedAreaRadius = focusedAreaRadius_buf;
+    return value;
+}
 inline void ToolbarItem_serializer::write(SerializerBase& buffer, Ark_ToolbarItem value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -92665,6 +94817,465 @@ inline Ark_VideoOptions VideoOptions_serializer::read(DeserializerBase& buffer)
     value.posterOptions = posterOptions_buf;
     return value;
 }
+inline void WeekStyle_serializer::write(SerializerBase& buffer, Ark_WeekStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_weekColor = value.weekColor;
+    Ark_Int32 value_weekColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekColor_type = runtimeType(value_weekColor);
+    valueSerializer.writeInt8(value_weekColor_type);
+    if ((value_weekColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekColor_value = value_weekColor.value;
+        Ark_Int32 value_weekColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_weekColor_value_type = value_weekColor_value.selector;
+        if (value_weekColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_weekColor_value_0 = value_weekColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_weekColor_value_0));
+        }
+        else if (value_weekColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_weekColor_value_1 = value_weekColor_value.value1;
+            valueSerializer.writeNumber(value_weekColor_value_1);
+        }
+        else if (value_weekColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_weekColor_value_2 = value_weekColor_value.value2;
+            valueSerializer.writeString(value_weekColor_value_2);
+        }
+        else if (value_weekColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_weekColor_value_3 = value_weekColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_weekColor_value_3);
+        }
+    }
+    const auto value_weekendDayColor = value.weekendDayColor;
+    Ark_Int32 value_weekendDayColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekendDayColor_type = runtimeType(value_weekendDayColor);
+    valueSerializer.writeInt8(value_weekendDayColor_type);
+    if ((value_weekendDayColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekendDayColor_value = value_weekendDayColor.value;
+        Ark_Int32 value_weekendDayColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_weekendDayColor_value_type = value_weekendDayColor_value.selector;
+        if (value_weekendDayColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_weekendDayColor_value_0 = value_weekendDayColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_weekendDayColor_value_0));
+        }
+        else if (value_weekendDayColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_weekendDayColor_value_1 = value_weekendDayColor_value.value1;
+            valueSerializer.writeNumber(value_weekendDayColor_value_1);
+        }
+        else if (value_weekendDayColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_weekendDayColor_value_2 = value_weekendDayColor_value.value2;
+            valueSerializer.writeString(value_weekendDayColor_value_2);
+        }
+        else if (value_weekendDayColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_weekendDayColor_value_3 = value_weekendDayColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_weekendDayColor_value_3);
+        }
+    }
+    const auto value_weekendLunarColor = value.weekendLunarColor;
+    Ark_Int32 value_weekendLunarColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekendLunarColor_type = runtimeType(value_weekendLunarColor);
+    valueSerializer.writeInt8(value_weekendLunarColor_type);
+    if ((value_weekendLunarColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekendLunarColor_value = value_weekendLunarColor.value;
+        Ark_Int32 value_weekendLunarColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_weekendLunarColor_value_type = value_weekendLunarColor_value.selector;
+        if (value_weekendLunarColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_weekendLunarColor_value_0 = value_weekendLunarColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_weekendLunarColor_value_0));
+        }
+        else if (value_weekendLunarColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_weekendLunarColor_value_1 = value_weekendLunarColor_value.value1;
+            valueSerializer.writeNumber(value_weekendLunarColor_value_1);
+        }
+        else if (value_weekendLunarColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_weekendLunarColor_value_2 = value_weekendLunarColor_value.value2;
+            valueSerializer.writeString(value_weekendLunarColor_value_2);
+        }
+        else if (value_weekendLunarColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_weekendLunarColor_value_3 = value_weekendLunarColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_weekendLunarColor_value_3);
+        }
+    }
+    const auto value_weekFontSize = value.weekFontSize;
+    Ark_Int32 value_weekFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekFontSize_type = runtimeType(value_weekFontSize);
+    valueSerializer.writeInt8(value_weekFontSize_type);
+    if ((value_weekFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekFontSize_value = value_weekFontSize.value;
+        valueSerializer.writeNumber(value_weekFontSize_value);
+    }
+    const auto value_weekHeight = value.weekHeight;
+    Ark_Int32 value_weekHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekHeight_type = runtimeType(value_weekHeight);
+    valueSerializer.writeInt8(value_weekHeight_type);
+    if ((value_weekHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekHeight_value = value_weekHeight.value;
+        valueSerializer.writeNumber(value_weekHeight_value);
+    }
+    const auto value_weekWidth = value.weekWidth;
+    Ark_Int32 value_weekWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekWidth_type = runtimeType(value_weekWidth);
+    valueSerializer.writeInt8(value_weekWidth_type);
+    if ((value_weekWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekWidth_value = value_weekWidth.value;
+        valueSerializer.writeNumber(value_weekWidth_value);
+    }
+    const auto value_weekAndDayRowSpace = value.weekAndDayRowSpace;
+    Ark_Int32 value_weekAndDayRowSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_weekAndDayRowSpace_type = runtimeType(value_weekAndDayRowSpace);
+    valueSerializer.writeInt8(value_weekAndDayRowSpace_type);
+    if ((value_weekAndDayRowSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_weekAndDayRowSpace_value = value_weekAndDayRowSpace.value;
+        valueSerializer.writeNumber(value_weekAndDayRowSpace_value);
+    }
+}
+inline Ark_WeekStyle WeekStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_WeekStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto weekColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor weekColor_buf = {};
+    weekColor_buf.tag = weekColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 weekColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor weekColor_buf_ = {};
+        weekColor_buf_.selector = weekColor_buf__selector;
+        if (weekColor_buf__selector == 0) {
+            weekColor_buf_.selector = 0;
+            weekColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (weekColor_buf__selector == 1) {
+            weekColor_buf_.selector = 1;
+            weekColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (weekColor_buf__selector == 2) {
+            weekColor_buf_.selector = 2;
+            weekColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (weekColor_buf__selector == 3) {
+            weekColor_buf_.selector = 3;
+            weekColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for weekColor_buf_ has to be chosen through deserialisation.");
+        }
+        weekColor_buf.value = static_cast<Ark_ResourceColor>(weekColor_buf_);
+    }
+    value.weekColor = weekColor_buf;
+    const auto weekendDayColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor weekendDayColor_buf = {};
+    weekendDayColor_buf.tag = weekendDayColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekendDayColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 weekendDayColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor weekendDayColor_buf_ = {};
+        weekendDayColor_buf_.selector = weekendDayColor_buf__selector;
+        if (weekendDayColor_buf__selector == 0) {
+            weekendDayColor_buf_.selector = 0;
+            weekendDayColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (weekendDayColor_buf__selector == 1) {
+            weekendDayColor_buf_.selector = 1;
+            weekendDayColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (weekendDayColor_buf__selector == 2) {
+            weekendDayColor_buf_.selector = 2;
+            weekendDayColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (weekendDayColor_buf__selector == 3) {
+            weekendDayColor_buf_.selector = 3;
+            weekendDayColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for weekendDayColor_buf_ has to be chosen through deserialisation.");
+        }
+        weekendDayColor_buf.value = static_cast<Ark_ResourceColor>(weekendDayColor_buf_);
+    }
+    value.weekendDayColor = weekendDayColor_buf;
+    const auto weekendLunarColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor weekendLunarColor_buf = {};
+    weekendLunarColor_buf.tag = weekendLunarColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekendLunarColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 weekendLunarColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor weekendLunarColor_buf_ = {};
+        weekendLunarColor_buf_.selector = weekendLunarColor_buf__selector;
+        if (weekendLunarColor_buf__selector == 0) {
+            weekendLunarColor_buf_.selector = 0;
+            weekendLunarColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (weekendLunarColor_buf__selector == 1) {
+            weekendLunarColor_buf_.selector = 1;
+            weekendLunarColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (weekendLunarColor_buf__selector == 2) {
+            weekendLunarColor_buf_.selector = 2;
+            weekendLunarColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (weekendLunarColor_buf__selector == 3) {
+            weekendLunarColor_buf_.selector = 3;
+            weekendLunarColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for weekendLunarColor_buf_ has to be chosen through deserialisation.");
+        }
+        weekendLunarColor_buf.value = static_cast<Ark_ResourceColor>(weekendLunarColor_buf_);
+    }
+    value.weekendLunarColor = weekendLunarColor_buf;
+    const auto weekFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number weekFontSize_buf = {};
+    weekFontSize_buf.tag = weekFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        weekFontSize_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.weekFontSize = weekFontSize_buf;
+    const auto weekHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number weekHeight_buf = {};
+    weekHeight_buf.tag = weekHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        weekHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.weekHeight = weekHeight_buf;
+    const auto weekWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number weekWidth_buf = {};
+    weekWidth_buf.tag = weekWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        weekWidth_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.weekWidth = weekWidth_buf;
+    const auto weekAndDayRowSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number weekAndDayRowSpace_buf = {};
+    weekAndDayRowSpace_buf.tag = weekAndDayRowSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((weekAndDayRowSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        weekAndDayRowSpace_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.weekAndDayRowSpace = weekAndDayRowSpace_buf;
+    return value;
+}
+inline void WorkStateStyle_serializer::write(SerializerBase& buffer, Ark_WorkStateStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_workDayMarkColor = value.workDayMarkColor;
+    Ark_Int32 value_workDayMarkColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_workDayMarkColor_type = runtimeType(value_workDayMarkColor);
+    valueSerializer.writeInt8(value_workDayMarkColor_type);
+    if ((value_workDayMarkColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_workDayMarkColor_value = value_workDayMarkColor.value;
+        Ark_Int32 value_workDayMarkColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_workDayMarkColor_value_type = value_workDayMarkColor_value.selector;
+        if (value_workDayMarkColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_workDayMarkColor_value_0 = value_workDayMarkColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_workDayMarkColor_value_0));
+        }
+        else if (value_workDayMarkColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_workDayMarkColor_value_1 = value_workDayMarkColor_value.value1;
+            valueSerializer.writeNumber(value_workDayMarkColor_value_1);
+        }
+        else if (value_workDayMarkColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_workDayMarkColor_value_2 = value_workDayMarkColor_value.value2;
+            valueSerializer.writeString(value_workDayMarkColor_value_2);
+        }
+        else if (value_workDayMarkColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_workDayMarkColor_value_3 = value_workDayMarkColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_workDayMarkColor_value_3);
+        }
+    }
+    const auto value_offDayMarkColor = value.offDayMarkColor;
+    Ark_Int32 value_offDayMarkColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offDayMarkColor_type = runtimeType(value_offDayMarkColor);
+    valueSerializer.writeInt8(value_offDayMarkColor_type);
+    if ((value_offDayMarkColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offDayMarkColor_value = value_offDayMarkColor.value;
+        Ark_Int32 value_offDayMarkColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_offDayMarkColor_value_type = value_offDayMarkColor_value.selector;
+        if (value_offDayMarkColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_offDayMarkColor_value_0 = value_offDayMarkColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_offDayMarkColor_value_0));
+        }
+        else if (value_offDayMarkColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_offDayMarkColor_value_1 = value_offDayMarkColor_value.value1;
+            valueSerializer.writeNumber(value_offDayMarkColor_value_1);
+        }
+        else if (value_offDayMarkColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_offDayMarkColor_value_2 = value_offDayMarkColor_value.value2;
+            valueSerializer.writeString(value_offDayMarkColor_value_2);
+        }
+        else if (value_offDayMarkColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_offDayMarkColor_value_3 = value_offDayMarkColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_offDayMarkColor_value_3);
+        }
+    }
+    const auto value_workDayMarkSize = value.workDayMarkSize;
+    Ark_Int32 value_workDayMarkSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_workDayMarkSize_type = runtimeType(value_workDayMarkSize);
+    valueSerializer.writeInt8(value_workDayMarkSize_type);
+    if ((value_workDayMarkSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_workDayMarkSize_value = value_workDayMarkSize.value;
+        valueSerializer.writeNumber(value_workDayMarkSize_value);
+    }
+    const auto value_offDayMarkSize = value.offDayMarkSize;
+    Ark_Int32 value_offDayMarkSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offDayMarkSize_type = runtimeType(value_offDayMarkSize);
+    valueSerializer.writeInt8(value_offDayMarkSize_type);
+    if ((value_offDayMarkSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offDayMarkSize_value = value_offDayMarkSize.value;
+        valueSerializer.writeNumber(value_offDayMarkSize_value);
+    }
+    const auto value_workStateWidth = value.workStateWidth;
+    Ark_Int32 value_workStateWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_workStateWidth_type = runtimeType(value_workStateWidth);
+    valueSerializer.writeInt8(value_workStateWidth_type);
+    if ((value_workStateWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_workStateWidth_value = value_workStateWidth.value;
+        valueSerializer.writeNumber(value_workStateWidth_value);
+    }
+    const auto value_workStateHorizontalMovingDistance = value.workStateHorizontalMovingDistance;
+    Ark_Int32 value_workStateHorizontalMovingDistance_type = INTEROP_RUNTIME_UNDEFINED;
+    value_workStateHorizontalMovingDistance_type = runtimeType(value_workStateHorizontalMovingDistance);
+    valueSerializer.writeInt8(value_workStateHorizontalMovingDistance_type);
+    if ((value_workStateHorizontalMovingDistance_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_workStateHorizontalMovingDistance_value = value_workStateHorizontalMovingDistance.value;
+        valueSerializer.writeNumber(value_workStateHorizontalMovingDistance_value);
+    }
+    const auto value_workStateVerticalMovingDistance = value.workStateVerticalMovingDistance;
+    Ark_Int32 value_workStateVerticalMovingDistance_type = INTEROP_RUNTIME_UNDEFINED;
+    value_workStateVerticalMovingDistance_type = runtimeType(value_workStateVerticalMovingDistance);
+    valueSerializer.writeInt8(value_workStateVerticalMovingDistance_type);
+    if ((value_workStateVerticalMovingDistance_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_workStateVerticalMovingDistance_value = value_workStateVerticalMovingDistance.value;
+        valueSerializer.writeNumber(value_workStateVerticalMovingDistance_value);
+    }
+}
+inline Ark_WorkStateStyle WorkStateStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_WorkStateStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto workDayMarkColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor workDayMarkColor_buf = {};
+    workDayMarkColor_buf.tag = workDayMarkColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((workDayMarkColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 workDayMarkColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor workDayMarkColor_buf_ = {};
+        workDayMarkColor_buf_.selector = workDayMarkColor_buf__selector;
+        if (workDayMarkColor_buf__selector == 0) {
+            workDayMarkColor_buf_.selector = 0;
+            workDayMarkColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (workDayMarkColor_buf__selector == 1) {
+            workDayMarkColor_buf_.selector = 1;
+            workDayMarkColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (workDayMarkColor_buf__selector == 2) {
+            workDayMarkColor_buf_.selector = 2;
+            workDayMarkColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (workDayMarkColor_buf__selector == 3) {
+            workDayMarkColor_buf_.selector = 3;
+            workDayMarkColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for workDayMarkColor_buf_ has to be chosen through deserialisation.");
+        }
+        workDayMarkColor_buf.value = static_cast<Ark_ResourceColor>(workDayMarkColor_buf_);
+    }
+    value.workDayMarkColor = workDayMarkColor_buf;
+    const auto offDayMarkColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor offDayMarkColor_buf = {};
+    offDayMarkColor_buf.tag = offDayMarkColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offDayMarkColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 offDayMarkColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor offDayMarkColor_buf_ = {};
+        offDayMarkColor_buf_.selector = offDayMarkColor_buf__selector;
+        if (offDayMarkColor_buf__selector == 0) {
+            offDayMarkColor_buf_.selector = 0;
+            offDayMarkColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (offDayMarkColor_buf__selector == 1) {
+            offDayMarkColor_buf_.selector = 1;
+            offDayMarkColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (offDayMarkColor_buf__selector == 2) {
+            offDayMarkColor_buf_.selector = 2;
+            offDayMarkColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (offDayMarkColor_buf__selector == 3) {
+            offDayMarkColor_buf_.selector = 3;
+            offDayMarkColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for offDayMarkColor_buf_ has to be chosen through deserialisation.");
+        }
+        offDayMarkColor_buf.value = static_cast<Ark_ResourceColor>(offDayMarkColor_buf_);
+    }
+    value.offDayMarkColor = offDayMarkColor_buf;
+    const auto workDayMarkSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number workDayMarkSize_buf = {};
+    workDayMarkSize_buf.tag = workDayMarkSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((workDayMarkSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        workDayMarkSize_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.workDayMarkSize = workDayMarkSize_buf;
+    const auto offDayMarkSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number offDayMarkSize_buf = {};
+    offDayMarkSize_buf.tag = offDayMarkSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offDayMarkSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offDayMarkSize_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.offDayMarkSize = offDayMarkSize_buf;
+    const auto workStateWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number workStateWidth_buf = {};
+    workStateWidth_buf.tag = workStateWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((workStateWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        workStateWidth_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.workStateWidth = workStateWidth_buf;
+    const auto workStateHorizontalMovingDistance_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number workStateHorizontalMovingDistance_buf = {};
+    workStateHorizontalMovingDistance_buf.tag = workStateHorizontalMovingDistance_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((workStateHorizontalMovingDistance_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        workStateHorizontalMovingDistance_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.workStateHorizontalMovingDistance = workStateHorizontalMovingDistance_buf;
+    const auto workStateVerticalMovingDistance_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number workStateVerticalMovingDistance_buf = {};
+    workStateVerticalMovingDistance_buf.tag = workStateVerticalMovingDistance_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((workStateVerticalMovingDistance_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        workStateVerticalMovingDistance_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.workStateVerticalMovingDistance = workStateVerticalMovingDistance_buf;
+    return value;
+}
 inline void XComponentOptions_serializer::write(SerializerBase& buffer, Ark_XComponentOptions value)
 {
     SerializerBase& valueSerializer = buffer;
@@ -103904,376 +106515,241 @@ inline Ark_CapsuleStyleOptions CapsuleStyleOptions_serializer::read(Deserializer
     value.borderRadius = borderRadius_buf;
     return value;
 }
-inline void CustomDialogControllerOptions_serializer::write(SerializerBase& buffer, Ark_CustomDialogControllerOptions value)
+inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_ContextMenuOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_builder = value.builder;
-    Ark_Int32 value_builder_type = INTEROP_RUNTIME_UNDEFINED;
-    value_builder_type = value_builder.selector;
-    if (value_builder_type == 0) {
-        valueSerializer.writeInt8(0);
-        const auto value_builder_0 = value_builder.value0;
-        valueSerializer.writeCallbackResource(value_builder_0.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder_0.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder_0.callSync));
-    }
-    else if (value_builder_type == 1) {
-        valueSerializer.writeInt8(1);
-        const auto value_builder_1 = value_builder.value1;
-        ExtendableComponent_serializer::write(valueSerializer, value_builder_1);
-    }
-    const auto value_cancel = value.cancel;
-    Ark_Int32 value_cancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_cancel_type = runtimeType(value_cancel);
-    valueSerializer.writeInt8(value_cancel_type);
-    if ((value_cancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_cancel_value = value_cancel.value;
-        valueSerializer.writeCallbackResource(value_cancel_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_cancel_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_cancel_value.callSync));
-    }
-    const auto value_autoCancel = value.autoCancel;
-    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_autoCancel_type = runtimeType(value_autoCancel);
-    valueSerializer.writeInt8(value_autoCancel_type);
-    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_autoCancel_value = value_autoCancel.value;
-        valueSerializer.writeBoolean(value_autoCancel_value);
-    }
-    const auto value_alignment = value.alignment;
-    Ark_Int32 value_alignment_type = INTEROP_RUNTIME_UNDEFINED;
-    value_alignment_type = runtimeType(value_alignment);
-    valueSerializer.writeInt8(value_alignment_type);
-    if ((value_alignment_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_alignment_value = value_alignment.value;
-        valueSerializer.writeInt32(static_cast<Ark_DialogAlignment>(value_alignment_value));
-    }
     const auto value_offset = value.offset;
     Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
     value_offset_type = runtimeType(value_offset);
     valueSerializer.writeInt8(value_offset_type);
     if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
         const auto value_offset_value = value_offset.value;
-        Offset_serializer::write(valueSerializer, value_offset_value);
+        Position_serializer::write(valueSerializer, value_offset_value);
     }
-    const auto value_customStyle = value.customStyle;
-    Ark_Int32 value_customStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_customStyle_type = runtimeType(value_customStyle);
-    valueSerializer.writeInt8(value_customStyle_type);
-    if ((value_customStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_customStyle_value = value_customStyle.value;
-        valueSerializer.writeBoolean(value_customStyle_value);
+    const auto value_placement = value.placement;
+    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placement_type = runtimeType(value_placement);
+    valueSerializer.writeInt8(value_placement_type);
+    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placement_value = value_placement.value;
+        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
     }
-    const auto value_gridCount = value.gridCount;
-    Ark_Int32 value_gridCount_type = INTEROP_RUNTIME_UNDEFINED;
-    value_gridCount_type = runtimeType(value_gridCount);
-    valueSerializer.writeInt8(value_gridCount_type);
-    if ((value_gridCount_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_gridCount_value = value_gridCount.value;
-        valueSerializer.writeNumber(value_gridCount_value);
+    const auto value_enableArrow = value.enableArrow;
+    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableArrow_type = runtimeType(value_enableArrow);
+    valueSerializer.writeInt8(value_enableArrow_type);
+    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableArrow_value = value_enableArrow.value;
+        valueSerializer.writeBoolean(value_enableArrow_value);
     }
-    const auto value_maskColor = value.maskColor;
-    Ark_Int32 value_maskColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maskColor_type = runtimeType(value_maskColor);
-    valueSerializer.writeInt8(value_maskColor_type);
-    if ((value_maskColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maskColor_value = value_maskColor.value;
-        Ark_Int32 value_maskColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_maskColor_value_type = value_maskColor_value.selector;
-        if (value_maskColor_value_type == 0) {
+    const auto value_arrowOffset = value.arrowOffset;
+    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowOffset_type = runtimeType(value_arrowOffset);
+    valueSerializer.writeInt8(value_arrowOffset_type);
+    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowOffset_value = value_arrowOffset.value;
+        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowOffset_value_type = value_arrowOffset_value.selector;
+        if (value_arrowOffset_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_maskColor_value_0 = value_maskColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_maskColor_value_0));
+            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
+            valueSerializer.writeString(value_arrowOffset_value_0);
         }
-        else if (value_maskColor_value_type == 1) {
+        else if (value_arrowOffset_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_maskColor_value_1 = value_maskColor_value.value1;
-            valueSerializer.writeNumber(value_maskColor_value_1);
+            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
+            valueSerializer.writeNumber(value_arrowOffset_value_1);
         }
-        else if (value_maskColor_value_type == 2) {
+        else if (value_arrowOffset_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_maskColor_value_2 = value_maskColor_value.value2;
-            valueSerializer.writeString(value_maskColor_value_2);
-        }
-        else if (value_maskColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_maskColor_value_3 = value_maskColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_maskColor_value_3);
+            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
         }
     }
-    const auto value_maskRect = value.maskRect;
-    Ark_Int32 value_maskRect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maskRect_type = runtimeType(value_maskRect);
-    valueSerializer.writeInt8(value_maskRect_type);
-    if ((value_maskRect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maskRect_value = value_maskRect.value;
-        Rectangle_serializer::write(valueSerializer, value_maskRect_value);
-    }
-    const auto value_openAnimation = value.openAnimation;
-    Ark_Int32 value_openAnimation_type = INTEROP_RUNTIME_UNDEFINED;
-    value_openAnimation_type = runtimeType(value_openAnimation);
-    valueSerializer.writeInt8(value_openAnimation_type);
-    if ((value_openAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_openAnimation_value = value_openAnimation.value;
-        AnimateParam_serializer::write(valueSerializer, value_openAnimation_value);
-    }
-    const auto value_closeAnimation = value.closeAnimation;
-    Ark_Int32 value_closeAnimation_type = INTEROP_RUNTIME_UNDEFINED;
-    value_closeAnimation_type = runtimeType(value_closeAnimation);
-    valueSerializer.writeInt8(value_closeAnimation_type);
-    if ((value_closeAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_closeAnimation_value = value_closeAnimation.value;
-        AnimateParam_serializer::write(valueSerializer, value_closeAnimation_value);
-    }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
-    }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value_preview = value.preview;
+    Ark_Int32 value_preview_type = INTEROP_RUNTIME_UNDEFINED;
+    value_preview_type = runtimeType(value_preview);
+    valueSerializer.writeInt8(value_preview_type);
+    if ((value_preview_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_preview_value = value_preview.value;
+        Ark_Int32 value_preview_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_preview_value_type = value_preview_value.selector;
+        if (value_preview_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_preview_value_0 = value_preview_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_MenuPreviewMode>(value_preview_value_0));
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_preview_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
-        }
-        else if (value_backgroundColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
-        }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_preview_value_1 = value_preview_value.value1;
+            valueSerializer.writeCallbackResource(value_preview_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.callSync));
         }
     }
-    const auto value_cornerRadius = value.cornerRadius;
-    Ark_Int32 value_cornerRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_cornerRadius_type = runtimeType(value_cornerRadius);
-    valueSerializer.writeInt8(value_cornerRadius_type);
-    if ((value_cornerRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_cornerRadius_value = value_cornerRadius.value;
-        Ark_Int32 value_cornerRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_cornerRadius_value_type = value_cornerRadius_value.selector;
-        if ((value_cornerRadius_value_type == 0) || (value_cornerRadius_value_type == 0) || (value_cornerRadius_value_type == 0)) {
+    const auto value_previewBorderRadius = value.previewBorderRadius;
+    Ark_Int32 value_previewBorderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_previewBorderRadius_type = runtimeType(value_previewBorderRadius);
+    valueSerializer.writeInt8(value_previewBorderRadius_type);
+    if ((value_previewBorderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_previewBorderRadius_value = value_previewBorderRadius.value;
+        Ark_Int32 value_previewBorderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_previewBorderRadius_value_type = value_previewBorderRadius_value.selector;
+        if ((value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_cornerRadius_value_0 = value_cornerRadius_value.value0;
-            Ark_Int32 value_cornerRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_cornerRadius_value_0_type = value_cornerRadius_value_0.selector;
-            if (value_cornerRadius_value_0_type == 0) {
+            const auto value_previewBorderRadius_value_0 = value_previewBorderRadius_value.value0;
+            Ark_Int32 value_previewBorderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_previewBorderRadius_value_0_type = value_previewBorderRadius_value_0.selector;
+            if (value_previewBorderRadius_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_cornerRadius_value_0_0 = value_cornerRadius_value_0.value0;
-                valueSerializer.writeString(value_cornerRadius_value_0_0);
+                const auto value_previewBorderRadius_value_0_0 = value_previewBorderRadius_value_0.value0;
+                valueSerializer.writeString(value_previewBorderRadius_value_0_0);
             }
-            else if (value_cornerRadius_value_0_type == 1) {
+            else if (value_previewBorderRadius_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_cornerRadius_value_0_1 = value_cornerRadius_value_0.value1;
-                valueSerializer.writeNumber(value_cornerRadius_value_0_1);
+                const auto value_previewBorderRadius_value_0_1 = value_previewBorderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_previewBorderRadius_value_0_1);
             }
-            else if (value_cornerRadius_value_0_type == 2) {
+            else if (value_previewBorderRadius_value_0_type == 2) {
                 valueSerializer.writeInt8(2);
-                const auto value_cornerRadius_value_0_2 = value_cornerRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_cornerRadius_value_0_2);
+                const auto value_previewBorderRadius_value_0_2 = value_previewBorderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_previewBorderRadius_value_0_2);
             }
         }
-        else if (value_cornerRadius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_cornerRadius_value_1 = value_cornerRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_cornerRadius_value_1);
-        }
-    }
-    const auto value_isModal = value.isModal;
-    Ark_Int32 value_isModal_type = INTEROP_RUNTIME_UNDEFINED;
-    value_isModal_type = runtimeType(value_isModal);
-    valueSerializer.writeInt8(value_isModal_type);
-    if ((value_isModal_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_isModal_value = value_isModal.value;
-        valueSerializer.writeBoolean(value_isModal_value);
-    }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
-    }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if (value_width_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            valueSerializer.writeString(value_width_value_0);
-        }
-        else if (value_width_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            valueSerializer.writeNumber(value_width_value_1);
-        }
-        else if (value_width_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_width_value_2 = value_width_value.value2;
-            Resource_serializer::write(valueSerializer, value_width_value_2);
-        }
-    }
-    const auto value_height = value.height;
-    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
-    value_height_type = runtimeType(value_height);
-    valueSerializer.writeInt8(value_height_type);
-    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_height_value = value_height.value;
-        Ark_Int32 value_height_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_height_value_type = value_height_value.selector;
-        if (value_height_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_height_value_0 = value_height_value.value0;
-            valueSerializer.writeString(value_height_value_0);
-        }
-        else if (value_height_value_type == 1) {
+        else if (value_previewBorderRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_height_value_1 = value_height_value.value1;
-            valueSerializer.writeNumber(value_height_value_1);
+            const auto value_previewBorderRadius_value_1 = value_previewBorderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_1);
         }
-        else if (value_height_value_type == 2) {
+        else if (value_previewBorderRadius_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_height_value_2 = value_height_value.value2;
-            Resource_serializer::write(valueSerializer, value_height_value_2);
+            const auto value_previewBorderRadius_value_2 = value_previewBorderRadius_value.value2;
+            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_2);
         }
     }
-    const auto value_borderWidth = value.borderWidth;
-    Ark_Int32 value_borderWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderWidth_type = runtimeType(value_borderWidth);
-    valueSerializer.writeInt8(value_borderWidth_type);
-    if ((value_borderWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderWidth_value = value_borderWidth.value;
-        Ark_Int32 value_borderWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderWidth_value_type = value_borderWidth_value.selector;
-        if ((value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0)) {
+    const auto value_borderRadius = value.borderRadius;
+    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderRadius_type = runtimeType(value_borderRadius);
+    valueSerializer.writeInt8(value_borderRadius_type);
+    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderRadius_value = value_borderRadius.value;
+        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderRadius_value_type = value_borderRadius_value.selector;
+        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_borderWidth_value_0 = value_borderWidth_value.value0;
-            Ark_Int32 value_borderWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderWidth_value_0_type = value_borderWidth_value_0.selector;
-            if (value_borderWidth_value_0_type == 0) {
+            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
+            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
+            if (value_borderRadius_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_borderWidth_value_0_0 = value_borderWidth_value_0.value0;
-                valueSerializer.writeString(value_borderWidth_value_0_0);
+                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
+                valueSerializer.writeString(value_borderRadius_value_0_0);
             }
-            else if (value_borderWidth_value_0_type == 1) {
+            else if (value_borderRadius_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_borderWidth_value_0_1 = value_borderWidth_value_0.value1;
-                valueSerializer.writeNumber(value_borderWidth_value_0_1);
+                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_borderRadius_value_0_1);
             }
-            else if (value_borderWidth_value_0_type == 2) {
+            else if (value_borderRadius_value_0_type == 2) {
                 valueSerializer.writeInt8(2);
-                const auto value_borderWidth_value_0_2 = value_borderWidth_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderWidth_value_0_2);
+                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
             }
         }
-        else if (value_borderWidth_value_type == 1) {
+        else if (value_borderRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_borderWidth_value_1 = value_borderWidth_value.value1;
-            EdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_1);
-        }
-    }
-    const auto value_borderColor = value.borderColor;
-    Ark_Int32 value_borderColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderColor_type = runtimeType(value_borderColor);
-    valueSerializer.writeInt8(value_borderColor_type);
-    if ((value_borderColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderColor_value = value_borderColor.value;
-        Ark_Int32 value_borderColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderColor_value_type = value_borderColor_value.selector;
-        if ((value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderColor_value_0 = value_borderColor_value.value0;
-            Ark_Int32 value_borderColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderColor_value_0_type = value_borderColor_value_0.selector;
-            if (value_borderColor_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderColor_value_0_0 = value_borderColor_value_0.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_borderColor_value_0_0));
-            }
-            else if (value_borderColor_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderColor_value_0_1 = value_borderColor_value_0.value1;
-                valueSerializer.writeNumber(value_borderColor_value_0_1);
-            }
-            else if (value_borderColor_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderColor_value_0_2 = value_borderColor_value_0.value2;
-                valueSerializer.writeString(value_borderColor_value_0_2);
-            }
-            else if (value_borderColor_value_0_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_borderColor_value_0_3 = value_borderColor_value_0.value3;
-                Resource_serializer::write(valueSerializer, value_borderColor_value_0_3);
-            }
+            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
         }
-        else if (value_borderColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderColor_value_1 = value_borderColor_value.value1;
-            EdgeColors_serializer::write(valueSerializer, value_borderColor_value_1);
+        else if (value_borderRadius_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_borderRadius_value_2 = value_borderRadius_value.value2;
+            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_2);
         }
     }
-    const auto value_borderStyle = value.borderStyle;
-    Ark_Int32 value_borderStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderStyle_type = runtimeType(value_borderStyle);
-    valueSerializer.writeInt8(value_borderStyle_type);
-    if ((value_borderStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderStyle_value = value_borderStyle.value;
-        Ark_Int32 value_borderStyle_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderStyle_value_type = value_borderStyle_value.selector;
-        if (value_borderStyle_value_type == 0) {
+    const auto value_onAppear = value.onAppear;
+    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onAppear_type = runtimeType(value_onAppear);
+    valueSerializer.writeInt8(value_onAppear_type);
+    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onAppear_value = value_onAppear.value;
+        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
+    }
+    const auto value_onDisappear = value.onDisappear;
+    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDisappear_type = runtimeType(value_onDisappear);
+    valueSerializer.writeInt8(value_onDisappear_type);
+    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDisappear_value = value_onDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
+    }
+    const auto value_aboutToAppear = value.aboutToAppear;
+    Ark_Int32 value_aboutToAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_aboutToAppear_type = runtimeType(value_aboutToAppear);
+    valueSerializer.writeInt8(value_aboutToAppear_type);
+    if ((value_aboutToAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_aboutToAppear_value = value_aboutToAppear.value;
+        valueSerializer.writeCallbackResource(value_aboutToAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.callSync));
+    }
+    const auto value_aboutToDisappear = value.aboutToDisappear;
+    Ark_Int32 value_aboutToDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_aboutToDisappear_type = runtimeType(value_aboutToDisappear);
+    valueSerializer.writeInt8(value_aboutToDisappear_type);
+    if ((value_aboutToDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_aboutToDisappear_value = value_aboutToDisappear.value;
+        valueSerializer.writeCallbackResource(value_aboutToDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.callSync));
+    }
+    const auto value_layoutRegionMargin = value.layoutRegionMargin;
+    Ark_Int32 value_layoutRegionMargin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin);
+    valueSerializer.writeInt8(value_layoutRegionMargin_type);
+    if ((value_layoutRegionMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutRegionMargin_value = value_layoutRegionMargin.value;
+        Padding_serializer::write(valueSerializer, value_layoutRegionMargin_value);
+    }
+    const auto value_previewAnimationOptions = value.previewAnimationOptions;
+    Ark_Int32 value_previewAnimationOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions);
+    valueSerializer.writeInt8(value_previewAnimationOptions_type);
+    if ((value_previewAnimationOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_previewAnimationOptions_value = value_previewAnimationOptions.value;
+        ContextMenuAnimationOptions_serializer::write(valueSerializer, value_previewAnimationOptions_value);
+    }
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_borderStyle_value_0 = value_borderStyle_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_BorderStyle>(value_borderStyle_value_0));
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_borderStyle_value_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_borderStyle_value_1 = value_borderStyle_value.value1;
-            EdgeStyles_serializer::write(valueSerializer, value_borderStyle_value_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-    }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+        else if (value_backgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
         }
-        else if (value_shadow_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
     const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
@@ -104300,248 +106776,318 @@ inline void CustomDialogControllerOptions_serializer::write(SerializerBase& buff
         const auto value_backgroundEffect_value = value_backgroundEffect.value;
         BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
     }
-    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
-    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
-    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
-    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
-    }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    }
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
         const auto value_enableHoverMode_value = value_enableHoverMode.value;
         valueSerializer.writeBoolean(value_enableHoverMode_value);
     }
-    const auto value_hoverModeArea = value.hoverModeArea;
-    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
-    valueSerializer.writeInt8(value_hoverModeArea_type);
-    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hoverModeArea_value = value_hoverModeArea.value;
-        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
-    }
-    const auto value_onDidAppear = value.onDidAppear;
-    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidAppear_type = runtimeType(value_onDidAppear);
-    valueSerializer.writeInt8(value_onDidAppear_type);
-    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidAppear_value = value_onDidAppear.value;
-        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
-    }
-    const auto value_onDidDisappear = value.onDidDisappear;
-    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
-    valueSerializer.writeInt8(value_onDidDisappear_type);
-    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidDisappear_value = value_onDidDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
-    }
-    const auto value_onWillAppear = value.onWillAppear;
-    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillAppear_type = runtimeType(value_onWillAppear);
-    valueSerializer.writeInt8(value_onWillAppear_type);
-    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillAppear_value = value_onWillAppear.value;
-        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
-    }
-    const auto value_onWillDisappear = value.onWillDisappear;
-    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
-    valueSerializer.writeInt8(value_onWillDisappear_type);
-    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDisappear_value = value_onWillDisappear.value;
-        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
-    }
-    const auto value_keyboardAvoidDistance = value.keyboardAvoidDistance;
-    Ark_Int32 value_keyboardAvoidDistance_type = INTEROP_RUNTIME_UNDEFINED;
-    value_keyboardAvoidDistance_type = runtimeType(value_keyboardAvoidDistance);
-    valueSerializer.writeInt8(value_keyboardAvoidDistance_type);
-    if ((value_keyboardAvoidDistance_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_keyboardAvoidDistance_value = value_keyboardAvoidDistance.value;
-        LengthMetrics_serializer::write(valueSerializer, value_keyboardAvoidDistance_value);
-    }
-    const auto value_levelMode = value.levelMode;
-    Ark_Int32 value_levelMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_levelMode_type = runtimeType(value_levelMode);
-    valueSerializer.writeInt8(value_levelMode_type);
-    if ((value_levelMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_levelMode_value = value_levelMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_LevelMode>(value_levelMode_value));
-    }
-    const auto value_levelUniqueId = value.levelUniqueId;
-    Ark_Int32 value_levelUniqueId_type = INTEROP_RUNTIME_UNDEFINED;
-    value_levelUniqueId_type = runtimeType(value_levelUniqueId);
-    valueSerializer.writeInt8(value_levelUniqueId_type);
-    if ((value_levelUniqueId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_levelUniqueId_value = value_levelUniqueId.value;
-        valueSerializer.writeNumber(value_levelUniqueId_value);
-    }
-    const auto value_immersiveMode = value.immersiveMode;
-    Ark_Int32 value_immersiveMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_immersiveMode_type = runtimeType(value_immersiveMode);
-    valueSerializer.writeInt8(value_immersiveMode_type);
-    if ((value_immersiveMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_immersiveMode_value = value_immersiveMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImmersiveMode>(value_immersiveMode_value));
+    const auto value_outlineColor = value.outlineColor;
+    Ark_Int32 value_outlineColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_outlineColor_type = runtimeType(value_outlineColor);
+    valueSerializer.writeInt8(value_outlineColor_type);
+    if ((value_outlineColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_outlineColor_value = value_outlineColor.value;
+        Ark_Int32 value_outlineColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_outlineColor_value_type = value_outlineColor_value.selector;
+        if ((value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_outlineColor_value_0 = value_outlineColor_value.value0;
+            Ark_Int32 value_outlineColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_outlineColor_value_0_type = value_outlineColor_value_0.selector;
+            if (value_outlineColor_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_outlineColor_value_0_0 = value_outlineColor_value_0.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_outlineColor_value_0_0));
+            }
+            else if (value_outlineColor_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_outlineColor_value_0_1 = value_outlineColor_value_0.value1;
+                valueSerializer.writeNumber(value_outlineColor_value_0_1);
+            }
+            else if (value_outlineColor_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_outlineColor_value_0_2 = value_outlineColor_value_0.value2;
+                valueSerializer.writeString(value_outlineColor_value_0_2);
+            }
+            else if (value_outlineColor_value_0_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_outlineColor_value_0_3 = value_outlineColor_value_0.value3;
+                Resource_serializer::write(valueSerializer, value_outlineColor_value_0_3);
+            }
+        }
+        else if (value_outlineColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_outlineColor_value_1 = value_outlineColor_value.value1;
+            EdgeColors_serializer::write(valueSerializer, value_outlineColor_value_1);
+        }
     }
-    const auto value_levelOrder = value.levelOrder;
-    Ark_Int32 value_levelOrder_type = INTEROP_RUNTIME_UNDEFINED;
-    value_levelOrder_type = runtimeType(value_levelOrder);
-    valueSerializer.writeInt8(value_levelOrder_type);
-    if ((value_levelOrder_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_levelOrder_value = value_levelOrder.value;
-        LevelOrder_serializer::write(valueSerializer, value_levelOrder_value);
+    const auto value_outlineWidth = value.outlineWidth;
+    Ark_Int32 value_outlineWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_outlineWidth_type = runtimeType(value_outlineWidth);
+    valueSerializer.writeInt8(value_outlineWidth_type);
+    if ((value_outlineWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_outlineWidth_value = value_outlineWidth.value;
+        Ark_Int32 value_outlineWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_outlineWidth_value_type = value_outlineWidth_value.selector;
+        if ((value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_outlineWidth_value_0 = value_outlineWidth_value.value0;
+            Ark_Int32 value_outlineWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_outlineWidth_value_0_type = value_outlineWidth_value_0.selector;
+            if (value_outlineWidth_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_outlineWidth_value_0_0 = value_outlineWidth_value_0.value0;
+                valueSerializer.writeString(value_outlineWidth_value_0_0);
+            }
+            else if (value_outlineWidth_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_outlineWidth_value_0_1 = value_outlineWidth_value_0.value1;
+                valueSerializer.writeNumber(value_outlineWidth_value_0_1);
+            }
+            else if (value_outlineWidth_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_outlineWidth_value_0_2 = value_outlineWidth_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_outlineWidth_value_0_2);
+            }
+        }
+        else if (value_outlineWidth_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_outlineWidth_value_1 = value_outlineWidth_value.value1;
+            EdgeOutlineWidths_serializer::write(valueSerializer, value_outlineWidth_value_1);
+        }
     }
-    const auto value_focusable = value.focusable;
-    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
-    value_focusable_type = runtimeType(value_focusable);
-    valueSerializer.writeInt8(value_focusable_type);
-    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_focusable_value = value_focusable.value;
-        valueSerializer.writeBoolean(value_focusable_value);
+    const auto value_hapticFeedbackMode = value.hapticFeedbackMode;
+    Ark_Int32 value_hapticFeedbackMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode);
+    valueSerializer.writeInt8(value_hapticFeedbackMode_type);
+    if ((value_hapticFeedbackMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hapticFeedbackMode_value = value_hapticFeedbackMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_HapticFeedbackMode>(value_hapticFeedbackMode_value));
     }
 }
-inline Ark_CustomDialogControllerOptions CustomDialogControllerOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_ContextMenuOptions ContextMenuOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_CustomDialogControllerOptions value = {};
+    Ark_ContextMenuOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const Ark_Int8 builder_buf_selector = valueDeserializer.readInt8();
-    Ark_Union_CustomBuilder_ExtendableComponent builder_buf = {};
-    builder_buf.selector = builder_buf_selector;
-    if (builder_buf_selector == 0) {
-        builder_buf.selector = 0;
-        builder_buf.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
-    }
-    else if (builder_buf_selector == 1) {
-        builder_buf.selector = 1;
-        builder_buf.value1 = static_cast<Ark_ExtendableComponent>(ExtendableComponent_serializer::read(valueDeserializer));
-    }
-    else {
-        INTEROP_FATAL("One of the branches for builder_buf has to be chosen through deserialisation.");
-    }
-    value.builder = static_cast<Ark_Union_CustomBuilder_ExtendableComponent>(builder_buf);
-    const auto cancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void cancel_buf = {};
-    cancel_buf.tag = cancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((cancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        cancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        offset_buf.value = Position_serializer::read(valueDeserializer);
     }
-    value.cancel = cancel_buf;
-    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean autoCancel_buf = {};
-    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.offset = offset_buf;
+    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Placement placement_buf = {};
+    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        autoCancel_buf.value = valueDeserializer.readBoolean();
+        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
     }
-    value.autoCancel = autoCancel_buf;
-    const auto alignment_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_DialogAlignment alignment_buf = {};
-    alignment_buf.tag = alignment_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((alignment_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.placement = placement_buf;
+    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableArrow_buf = {};
+    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        alignment_buf.value = static_cast<Ark_DialogAlignment>(valueDeserializer.readInt32());
+        enableArrow_buf.value = valueDeserializer.readBoolean();
     }
-    value.alignment = alignment_buf;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Offset offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.enableArrow = enableArrow_buf;
+    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length arrowOffset_buf = {};
+    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = Offset_serializer::read(valueDeserializer);
+        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
+        Ark_Length arrowOffset_buf_ = {};
+        arrowOffset_buf_.selector = arrowOffset_buf__selector;
+        if (arrowOffset_buf__selector == 0) {
+            arrowOffset_buf_.selector = 0;
+            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowOffset_buf__selector == 1) {
+            arrowOffset_buf_.selector = 1;
+            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowOffset_buf__selector == 2) {
+            arrowOffset_buf_.selector = 2;
+            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
+        }
+        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
     }
-    value.offset = offset_buf;
-    const auto customStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean customStyle_buf = {};
-    customStyle_buf.tag = customStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((customStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowOffset = arrowOffset_buf;
+    const auto preview_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_MenuPreviewMode_CustomBuilder preview_buf = {};
+    preview_buf.tag = preview_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((preview_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        customStyle_buf.value = valueDeserializer.readBoolean();
+        const Ark_Int8 preview_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_MenuPreviewMode_CustomBuilder preview_buf_ = {};
+        preview_buf_.selector = preview_buf__selector;
+        if (preview_buf__selector == 0) {
+            preview_buf_.selector = 0;
+            preview_buf_.value0 = static_cast<Ark_MenuPreviewMode>(valueDeserializer.readInt32());
+        }
+        else if (preview_buf__selector == 1) {
+            preview_buf_.selector = 1;
+            preview_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        }
+        else {
+            INTEROP_FATAL("One of the branches for preview_buf_ has to be chosen through deserialisation.");
+        }
+        preview_buf.value = static_cast<Ark_Union_MenuPreviewMode_CustomBuilder>(preview_buf_);
     }
-    value.customStyle = customStyle_buf;
-    const auto gridCount_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number gridCount_buf = {};
-    gridCount_buf.tag = gridCount_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((gridCount_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.preview = preview_buf;
+    const auto previewBorderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BorderRadiusType previewBorderRadius_buf = {};
+    previewBorderRadius_buf.tag = previewBorderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((previewBorderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        gridCount_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 previewBorderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_BorderRadiusType previewBorderRadius_buf_ = {};
+        previewBorderRadius_buf_.selector = previewBorderRadius_buf__selector;
+        if (previewBorderRadius_buf__selector == 0) {
+            previewBorderRadius_buf_.selector = 0;
+            const Ark_Int8 previewBorderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length previewBorderRadius_buf__u = {};
+            previewBorderRadius_buf__u.selector = previewBorderRadius_buf__u_selector;
+            if (previewBorderRadius_buf__u_selector == 0) {
+                previewBorderRadius_buf__u.selector = 0;
+                previewBorderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (previewBorderRadius_buf__u_selector == 1) {
+                previewBorderRadius_buf__u.selector = 1;
+                previewBorderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (previewBorderRadius_buf__u_selector == 2) {
+                previewBorderRadius_buf__u.selector = 2;
+                previewBorderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.");
+            }
+            previewBorderRadius_buf_.value0 = static_cast<Ark_Length>(previewBorderRadius_buf__u);
+        }
+        else if (previewBorderRadius_buf__selector == 1) {
+            previewBorderRadius_buf_.selector = 1;
+            previewBorderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        }
+        else if (previewBorderRadius_buf__selector == 2) {
+            previewBorderRadius_buf_.selector = 2;
+            previewBorderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.");
+        }
+        previewBorderRadius_buf.value = static_cast<Ark_BorderRadiusType>(previewBorderRadius_buf_);
     }
-    value.gridCount = gridCount_buf;
-    const auto maskColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor maskColor_buf = {};
-    maskColor_buf.tag = maskColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maskColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.previewBorderRadius = previewBorderRadius_buf;
+    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf = {};
+    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 maskColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor maskColor_buf_ = {};
-        maskColor_buf_.selector = maskColor_buf__selector;
-        if (maskColor_buf__selector == 0) {
-            maskColor_buf_.selector = 0;
-            maskColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (maskColor_buf__selector == 1) {
-            maskColor_buf_.selector = 1;
-            maskColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf_ = {};
+        borderRadius_buf_.selector = borderRadius_buf__selector;
+        if (borderRadius_buf__selector == 0) {
+            borderRadius_buf_.selector = 0;
+            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length borderRadius_buf__u = {};
+            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
+            if (borderRadius_buf__u_selector == 0) {
+                borderRadius_buf__u.selector = 0;
+                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderRadius_buf__u_selector == 1) {
+                borderRadius_buf__u.selector = 1;
+                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderRadius_buf__u_selector == 2) {
+                borderRadius_buf__u.selector = 2;
+                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
+            }
+            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
         }
-        else if (maskColor_buf__selector == 2) {
-            maskColor_buf_.selector = 2;
-            maskColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (borderRadius_buf__selector == 1) {
+            borderRadius_buf_.selector = 1;
+            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
-        else if (maskColor_buf__selector == 3) {
-            maskColor_buf_.selector = 3;
-            maskColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (borderRadius_buf__selector == 2) {
+            borderRadius_buf_.selector = 2;
+            borderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for maskColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
         }
-        maskColor_buf.value = static_cast<Ark_ResourceColor>(maskColor_buf_);
+        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses>(borderRadius_buf_);
     }
-    value.maskColor = maskColor_buf;
-    const auto maskRect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Rectangle maskRect_buf = {};
-    maskRect_buf.tag = maskRect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maskRect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.borderRadius = borderRadius_buf;
+    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onAppear_buf = {};
+    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        maskRect_buf.value = Rectangle_serializer::read(valueDeserializer);
+        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.maskRect = maskRect_buf;
-    const auto openAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_AnimateParam openAnimation_buf = {};
-    openAnimation_buf.tag = openAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((openAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onAppear = onAppear_buf;
+    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDisappear_buf = {};
+    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        openAnimation_buf.value = AnimateParam_serializer::read(valueDeserializer);
+        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.openAnimation = openAnimation_buf;
-    const auto closeAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_AnimateParam closeAnimation_buf = {};
-    closeAnimation_buf.tag = closeAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((closeAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onDisappear = onDisappear_buf;
+    const auto aboutToAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void aboutToAppear_buf = {};
+    aboutToAppear_buf.tag = aboutToAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((aboutToAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        closeAnimation_buf.value = AnimateParam_serializer::read(valueDeserializer);
+        aboutToAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.closeAnimation = closeAnimation_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.aboutToAppear = aboutToAppear_buf;
+    const auto aboutToDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void aboutToDisappear_buf = {};
+    aboutToDisappear_buf.tag = aboutToDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((aboutToDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+        aboutToDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.showInSubWindow = showInSubWindow_buf;
+    value.aboutToDisappear = aboutToDisappear_buf;
+    const auto layoutRegionMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Padding layoutRegionMargin_buf = {};
+    layoutRegionMargin_buf.tag = layoutRegionMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutRegionMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        layoutRegionMargin_buf.value = Padding_serializer::read(valueDeserializer);
+    }
+    value.layoutRegionMargin = layoutRegionMargin_buf;
+    const auto previewAnimationOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ContextMenuAnimationOptions previewAnimationOptions_buf = {};
+    previewAnimationOptions_buf.tag = previewAnimationOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((previewAnimationOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        previewAnimationOptions_buf.value = ContextMenuAnimationOptions_serializer::read(valueDeserializer);
+    }
+    value.previewAnimationOptions = previewAnimationOptions_buf;
     const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_ResourceColor backgroundColor_buf = {};
     backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -104572,248 +107118,12 @@ inline Ark_CustomDialogControllerOptions CustomDialogControllerOptions_serialize
         backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
     value.backgroundColor = backgroundColor_buf;
-    const auto cornerRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_BorderRadiuses cornerRadius_buf = {};
-    cornerRadius_buf.tag = cornerRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((cornerRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 cornerRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_BorderRadiuses cornerRadius_buf_ = {};
-        cornerRadius_buf_.selector = cornerRadius_buf__selector;
-        if (cornerRadius_buf__selector == 0) {
-            cornerRadius_buf_.selector = 0;
-            const Ark_Int8 cornerRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension cornerRadius_buf__u = {};
-            cornerRadius_buf__u.selector = cornerRadius_buf__u_selector;
-            if (cornerRadius_buf__u_selector == 0) {
-                cornerRadius_buf__u.selector = 0;
-                cornerRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (cornerRadius_buf__u_selector == 1) {
-                cornerRadius_buf__u.selector = 1;
-                cornerRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (cornerRadius_buf__u_selector == 2) {
-                cornerRadius_buf__u.selector = 2;
-                cornerRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for cornerRadius_buf__u has to be chosen through deserialisation.");
-            }
-            cornerRadius_buf_.value0 = static_cast<Ark_Dimension>(cornerRadius_buf__u);
-        }
-        else if (cornerRadius_buf__selector == 1) {
-            cornerRadius_buf_.selector = 1;
-            cornerRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for cornerRadius_buf_ has to be chosen through deserialisation.");
-        }
-        cornerRadius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(cornerRadius_buf_);
-    }
-    value.cornerRadius = cornerRadius_buf;
-    const auto isModal_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean isModal_buf = {};
-    isModal_buf.tag = isModal_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((isModal_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        isModal_buf.value = valueDeserializer.readBoolean();
-    }
-    value.isModal = isModal_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_DismissDialogAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissDialogAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissDialogAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissDialogAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissDialogAction_Void))))};
-    }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension width_buf_ = {};
-        width_buf_.selector = width_buf__selector;
-        if (width_buf__selector == 0) {
-            width_buf_.selector = 0;
-            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (width_buf__selector == 2) {
-            width_buf_.selector = 2;
-            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
-        }
-        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
-    }
-    value.width = width_buf;
-    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension height_buf = {};
-    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 height_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension height_buf_ = {};
-        height_buf_.selector = height_buf__selector;
-        if (height_buf__selector == 0) {
-            height_buf_.selector = 0;
-            height_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (height_buf__selector == 1) {
-            height_buf_.selector = 1;
-            height_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (height_buf__selector == 2) {
-            height_buf_.selector = 2;
-            height_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for height_buf_ has to be chosen through deserialisation.");
-        }
-        height_buf.value = static_cast<Ark_Dimension>(height_buf_);
-    }
-    value.height = height_buf;
-    const auto borderWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_EdgeWidths borderWidth_buf = {};
-    borderWidth_buf.tag = borderWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_EdgeWidths borderWidth_buf_ = {};
-        borderWidth_buf_.selector = borderWidth_buf__selector;
-        if (borderWidth_buf__selector == 0) {
-            borderWidth_buf_.selector = 0;
-            const Ark_Int8 borderWidth_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension borderWidth_buf__u = {};
-            borderWidth_buf__u.selector = borderWidth_buf__u_selector;
-            if (borderWidth_buf__u_selector == 0) {
-                borderWidth_buf__u.selector = 0;
-                borderWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderWidth_buf__u_selector == 1) {
-                borderWidth_buf__u.selector = 1;
-                borderWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderWidth_buf__u_selector == 2) {
-                borderWidth_buf__u.selector = 2;
-                borderWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.");
-            }
-            borderWidth_buf_.value0 = static_cast<Ark_Dimension>(borderWidth_buf__u);
-        }
-        else if (borderWidth_buf__selector == 1) {
-            borderWidth_buf_.selector = 1;
-            borderWidth_buf_.value1 = EdgeWidths_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.");
-        }
-        borderWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeWidths>(borderWidth_buf_);
-    }
-    value.borderWidth = borderWidth_buf;
-    const auto borderColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceColor_EdgeColors borderColor_buf = {};
-    borderColor_buf.tag = borderColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceColor_EdgeColors borderColor_buf_ = {};
-        borderColor_buf_.selector = borderColor_buf__selector;
-        if (borderColor_buf__selector == 0) {
-            borderColor_buf_.selector = 0;
-            const Ark_Int8 borderColor_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor borderColor_buf__u = {};
-            borderColor_buf__u.selector = borderColor_buf__u_selector;
-            if (borderColor_buf__u_selector == 0) {
-                borderColor_buf__u.selector = 0;
-                borderColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-            }
-            else if (borderColor_buf__u_selector == 1) {
-                borderColor_buf__u.selector = 1;
-                borderColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderColor_buf__u_selector == 2) {
-                borderColor_buf__u.selector = 2;
-                borderColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderColor_buf__u_selector == 3) {
-                borderColor_buf__u.selector = 3;
-                borderColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderColor_buf__u has to be chosen through deserialisation.");
-            }
-            borderColor_buf_.value0 = static_cast<Ark_ResourceColor>(borderColor_buf__u);
-        }
-        else if (borderColor_buf__selector == 1) {
-            borderColor_buf_.selector = 1;
-            borderColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for borderColor_buf_ has to be chosen through deserialisation.");
-        }
-        borderColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(borderColor_buf_);
-    }
-    value.borderColor = borderColor_buf;
-    const auto borderStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_BorderStyle_EdgeStyles borderStyle_buf = {};
-    borderStyle_buf.tag = borderStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderStyle_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_BorderStyle_EdgeStyles borderStyle_buf_ = {};
-        borderStyle_buf_.selector = borderStyle_buf__selector;
-        if (borderStyle_buf__selector == 0) {
-            borderStyle_buf_.selector = 0;
-            borderStyle_buf_.value0 = static_cast<Ark_BorderStyle>(valueDeserializer.readInt32());
-        }
-        else if (borderStyle_buf__selector == 1) {
-            borderStyle_buf_.selector = 1;
-            borderStyle_buf_.value1 = EdgeStyles_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.");
-        }
-        borderStyle_buf.value = static_cast<Ark_Union_BorderStyle_EdgeStyles>(borderStyle_buf_);
-    }
-    value.borderStyle = borderStyle_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
-        }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
-        }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
-    }
-    value.shadow = shadow_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
     value.backgroundBlurStyle = backgroundBlurStyle_buf;
     const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
@@ -104832,14 +107142,14 @@ inline Ark_CustomDialogControllerOptions CustomDialogControllerOptions_serialize
         backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
     }
     value.backgroundEffect = backgroundEffect_buf;
-    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
-    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
     }
-    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    value.transition = transition_buf;
     const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Boolean enableHoverMode_buf = {};
     enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -104848,1433 +107158,1287 @@ inline Ark_CustomDialogControllerOptions CustomDialogControllerOptions_serialize
         enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
     value.enableHoverMode = enableHoverMode_buf;
-    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HoverModeAreaType hoverModeArea_buf = {};
-    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto outlineColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceColor_EdgeColors outlineColor_buf = {};
+    outlineColor_buf.tag = outlineColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((outlineColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
+        const Ark_Int8 outlineColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceColor_EdgeColors outlineColor_buf_ = {};
+        outlineColor_buf_.selector = outlineColor_buf__selector;
+        if (outlineColor_buf__selector == 0) {
+            outlineColor_buf_.selector = 0;
+            const Ark_Int8 outlineColor_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor outlineColor_buf__u = {};
+            outlineColor_buf__u.selector = outlineColor_buf__u_selector;
+            if (outlineColor_buf__u_selector == 0) {
+                outlineColor_buf__u.selector = 0;
+                outlineColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+            }
+            else if (outlineColor_buf__u_selector == 1) {
+                outlineColor_buf__u.selector = 1;
+                outlineColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (outlineColor_buf__u_selector == 2) {
+                outlineColor_buf__u.selector = 2;
+                outlineColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (outlineColor_buf__u_selector == 3) {
+                outlineColor_buf__u.selector = 3;
+                outlineColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.");
+            }
+            outlineColor_buf_.value0 = static_cast<Ark_ResourceColor>(outlineColor_buf__u);
+        }
+        else if (outlineColor_buf__selector == 1) {
+            outlineColor_buf_.selector = 1;
+            outlineColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.");
+        }
+        outlineColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(outlineColor_buf_);
     }
-    value.hoverModeArea = hoverModeArea_buf;
-    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDidAppear_buf = {};
-    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.outlineColor = outlineColor_buf;
+    const auto outlineWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth_buf = {};
+    outlineWidth_buf.tag = outlineWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((outlineWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        const Ark_Int8 outlineWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_EdgeOutlineWidths outlineWidth_buf_ = {};
+        outlineWidth_buf_.selector = outlineWidth_buf__selector;
+        if (outlineWidth_buf__selector == 0) {
+            outlineWidth_buf_.selector = 0;
+            const Ark_Int8 outlineWidth_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension outlineWidth_buf__u = {};
+            outlineWidth_buf__u.selector = outlineWidth_buf__u_selector;
+            if (outlineWidth_buf__u_selector == 0) {
+                outlineWidth_buf__u.selector = 0;
+                outlineWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (outlineWidth_buf__u_selector == 1) {
+                outlineWidth_buf__u.selector = 1;
+                outlineWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (outlineWidth_buf__u_selector == 2) {
+                outlineWidth_buf__u.selector = 2;
+                outlineWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.");
+            }
+            outlineWidth_buf_.value0 = static_cast<Ark_Dimension>(outlineWidth_buf__u);
+        }
+        else if (outlineWidth_buf__selector == 1) {
+            outlineWidth_buf_.selector = 1;
+            outlineWidth_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.");
+        }
+        outlineWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(outlineWidth_buf_);
     }
-    value.onDidAppear = onDidAppear_buf;
-    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDidDisappear_buf = {};
-    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.outlineWidth = outlineWidth_buf;
+    const auto hapticFeedbackMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HapticFeedbackMode hapticFeedbackMode_buf = {};
+    hapticFeedbackMode_buf.tag = hapticFeedbackMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hapticFeedbackMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        hapticFeedbackMode_buf.value = static_cast<Ark_HapticFeedbackMode>(valueDeserializer.readInt32());
     }
-    value.onDidDisappear = onDidDisappear_buf;
-    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillAppear_buf = {};
-    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    value.hapticFeedbackMode = hapticFeedbackMode_buf;
+    return value;
+}
+inline void CustomDialogControllerOptions_serializer::write(SerializerBase& buffer, Ark_CustomDialogControllerOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_builder = value.builder;
+    Ark_Int32 value_builder_type = INTEROP_RUNTIME_UNDEFINED;
+    value_builder_type = value_builder.selector;
+    if (value_builder_type == 0) {
+        valueSerializer.writeInt8(0);
+        const auto value_builder_0 = value_builder.value0;
+        valueSerializer.writeCallbackResource(value_builder_0.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder_0.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder_0.callSync));
     }
-    value.onWillAppear = onWillAppear_buf;
-    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillDisappear_buf = {};
-    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    else if (value_builder_type == 1) {
+        valueSerializer.writeInt8(1);
+        const auto value_builder_1 = value_builder.value1;
+        ExtendableComponent_serializer::write(valueSerializer, value_builder_1);
     }
-    value.onWillDisappear = onWillDisappear_buf;
-    const auto keyboardAvoidDistance_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LengthMetrics keyboardAvoidDistance_buf = {};
-    keyboardAvoidDistance_buf.tag = keyboardAvoidDistance_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((keyboardAvoidDistance_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        keyboardAvoidDistance_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+    const auto value_cancel = value.cancel;
+    Ark_Int32 value_cancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_cancel_type = runtimeType(value_cancel);
+    valueSerializer.writeInt8(value_cancel_type);
+    if ((value_cancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_cancel_value = value_cancel.value;
+        valueSerializer.writeCallbackResource(value_cancel_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_cancel_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_cancel_value.callSync));
     }
-    value.keyboardAvoidDistance = keyboardAvoidDistance_buf;
-    const auto levelMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LevelMode levelMode_buf = {};
-    levelMode_buf.tag = levelMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((levelMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        levelMode_buf.value = static_cast<Ark_LevelMode>(valueDeserializer.readInt32());
+    const auto value_autoCancel = value.autoCancel;
+    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_autoCancel_type = runtimeType(value_autoCancel);
+    valueSerializer.writeInt8(value_autoCancel_type);
+    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_autoCancel_value = value_autoCancel.value;
+        valueSerializer.writeBoolean(value_autoCancel_value);
     }
-    value.levelMode = levelMode_buf;
-    const auto levelUniqueId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number levelUniqueId_buf = {};
-    levelUniqueId_buf.tag = levelUniqueId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((levelUniqueId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        levelUniqueId_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto value_alignment = value.alignment;
+    Ark_Int32 value_alignment_type = INTEROP_RUNTIME_UNDEFINED;
+    value_alignment_type = runtimeType(value_alignment);
+    valueSerializer.writeInt8(value_alignment_type);
+    if ((value_alignment_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_alignment_value = value_alignment.value;
+        valueSerializer.writeInt32(static_cast<Ark_DialogAlignment>(value_alignment_value));
     }
-    value.levelUniqueId = levelUniqueId_buf;
-    const auto immersiveMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImmersiveMode immersiveMode_buf = {};
-    immersiveMode_buf.tag = immersiveMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((immersiveMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        immersiveMode_buf.value = static_cast<Ark_ImmersiveMode>(valueDeserializer.readInt32());
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Offset_serializer::write(valueSerializer, value_offset_value);
     }
-    value.immersiveMode = immersiveMode_buf;
-    const auto levelOrder_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LevelOrder levelOrder_buf = {};
-    levelOrder_buf.tag = levelOrder_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((levelOrder_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        levelOrder_buf.value = static_cast<Ark_LevelOrder>(LevelOrder_serializer::read(valueDeserializer));
+    const auto value_customStyle = value.customStyle;
+    Ark_Int32 value_customStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_customStyle_type = runtimeType(value_customStyle);
+    valueSerializer.writeInt8(value_customStyle_type);
+    if ((value_customStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_customStyle_value = value_customStyle.value;
+        valueSerializer.writeBoolean(value_customStyle_value);
     }
-    value.levelOrder = levelOrder_buf;
-    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean focusable_buf = {};
-    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        focusable_buf.value = valueDeserializer.readBoolean();
+    const auto value_gridCount = value.gridCount;
+    Ark_Int32 value_gridCount_type = INTEROP_RUNTIME_UNDEFINED;
+    value_gridCount_type = runtimeType(value_gridCount);
+    valueSerializer.writeInt8(value_gridCount_type);
+    if ((value_gridCount_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_gridCount_value = value_gridCount.value;
+        valueSerializer.writeNumber(value_gridCount_value);
     }
-    value.focusable = focusable_buf;
-    return value;
-}
-inline void DigitIndicator_serializer::write(SerializerBase& buffer, Ark_DigitIndicator value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value__left = value._left;
-    Ark_Int32 value__left_type = INTEROP_RUNTIME_UNDEFINED;
-    value__left_type = runtimeType(value__left);
-    valueSerializer.writeInt8(value__left_type);
-    if ((value__left_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__left_value = value__left.value;
-        Ark_Int32 value__left_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__left_value_type = value__left_value.selector;
-        if (value__left_value_type == 0) {
+    const auto value_maskColor = value.maskColor;
+    Ark_Int32 value_maskColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maskColor_type = runtimeType(value_maskColor);
+    valueSerializer.writeInt8(value_maskColor_type);
+    if ((value_maskColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maskColor_value = value_maskColor.value;
+        Ark_Int32 value_maskColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_maskColor_value_type = value_maskColor_value.selector;
+        if (value_maskColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__left_value_0 = value__left_value.value0;
-            valueSerializer.writeString(value__left_value_0);
+            const auto value_maskColor_value_0 = value_maskColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_maskColor_value_0));
         }
-        else if (value__left_value_type == 1) {
+        else if (value_maskColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__left_value_1 = value__left_value.value1;
-            valueSerializer.writeNumber(value__left_value_1);
+            const auto value_maskColor_value_1 = value_maskColor_value.value1;
+            valueSerializer.writeNumber(value_maskColor_value_1);
         }
-        else if (value__left_value_type == 2) {
+        else if (value_maskColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value__left_value_2 = value__left_value.value2;
-            Resource_serializer::write(valueSerializer, value__left_value_2);
-        }
-    }
-    const auto value__top = value._top;
-    Ark_Int32 value__top_type = INTEROP_RUNTIME_UNDEFINED;
-    value__top_type = runtimeType(value__top);
-    valueSerializer.writeInt8(value__top_type);
-    if ((value__top_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__top_value = value__top.value;
-        Ark_Int32 value__top_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__top_value_type = value__top_value.selector;
-        if (value__top_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value__top_value_0 = value__top_value.value0;
-            valueSerializer.writeString(value__top_value_0);
-        }
-        else if (value__top_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value__top_value_1 = value__top_value.value1;
-            valueSerializer.writeNumber(value__top_value_1);
+            const auto value_maskColor_value_2 = value_maskColor_value.value2;
+            valueSerializer.writeString(value_maskColor_value_2);
         }
-        else if (value__top_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value__top_value_2 = value__top_value.value2;
-            Resource_serializer::write(valueSerializer, value__top_value_2);
+        else if (value_maskColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_maskColor_value_3 = value_maskColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_maskColor_value_3);
         }
     }
-    const auto value__right = value._right;
-    Ark_Int32 value__right_type = INTEROP_RUNTIME_UNDEFINED;
-    value__right_type = runtimeType(value__right);
-    valueSerializer.writeInt8(value__right_type);
-    if ((value__right_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__right_value = value__right.value;
-        Ark_Int32 value__right_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__right_value_type = value__right_value.selector;
-        if (value__right_value_type == 0) {
+    const auto value_maskRect = value.maskRect;
+    Ark_Int32 value_maskRect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maskRect_type = runtimeType(value_maskRect);
+    valueSerializer.writeInt8(value_maskRect_type);
+    if ((value_maskRect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maskRect_value = value_maskRect.value;
+        Rectangle_serializer::write(valueSerializer, value_maskRect_value);
+    }
+    const auto value_openAnimation = value.openAnimation;
+    Ark_Int32 value_openAnimation_type = INTEROP_RUNTIME_UNDEFINED;
+    value_openAnimation_type = runtimeType(value_openAnimation);
+    valueSerializer.writeInt8(value_openAnimation_type);
+    if ((value_openAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_openAnimation_value = value_openAnimation.value;
+        AnimateParam_serializer::write(valueSerializer, value_openAnimation_value);
+    }
+    const auto value_closeAnimation = value.closeAnimation;
+    Ark_Int32 value_closeAnimation_type = INTEROP_RUNTIME_UNDEFINED;
+    value_closeAnimation_type = runtimeType(value_closeAnimation);
+    valueSerializer.writeInt8(value_closeAnimation_type);
+    if ((value_closeAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_closeAnimation_value = value_closeAnimation.value;
+        AnimateParam_serializer::write(valueSerializer, value_closeAnimation_value);
+    }
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
+    }
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__right_value_0 = value__right_value.value0;
-            valueSerializer.writeString(value__right_value_0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value__right_value_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__right_value_1 = value__right_value.value1;
-            valueSerializer.writeNumber(value__right_value_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-        else if (value__right_value_type == 2) {
+        else if (value_backgroundColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value__right_value_2 = value__right_value.value2;
-            Resource_serializer::write(valueSerializer, value__right_value_2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
+        }
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
-    const auto value__bottom = value._bottom;
-    Ark_Int32 value__bottom_type = INTEROP_RUNTIME_UNDEFINED;
-    value__bottom_type = runtimeType(value__bottom);
-    valueSerializer.writeInt8(value__bottom_type);
-    if ((value__bottom_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__bottom_value = value__bottom.value;
-        Ark_Int32 value__bottom_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__bottom_value_type = value__bottom_value.selector;
-        if (value__bottom_value_type == 0) {
+    const auto value_cornerRadius = value.cornerRadius;
+    Ark_Int32 value_cornerRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_cornerRadius_type = runtimeType(value_cornerRadius);
+    valueSerializer.writeInt8(value_cornerRadius_type);
+    if ((value_cornerRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_cornerRadius_value = value_cornerRadius.value;
+        Ark_Int32 value_cornerRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_cornerRadius_value_type = value_cornerRadius_value.selector;
+        if ((value_cornerRadius_value_type == 0) || (value_cornerRadius_value_type == 0) || (value_cornerRadius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value__bottom_value_0 = value__bottom_value.value0;
-            valueSerializer.writeString(value__bottom_value_0);
+            const auto value_cornerRadius_value_0 = value_cornerRadius_value.value0;
+            Ark_Int32 value_cornerRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_cornerRadius_value_0_type = value_cornerRadius_value_0.selector;
+            if (value_cornerRadius_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_cornerRadius_value_0_0 = value_cornerRadius_value_0.value0;
+                valueSerializer.writeString(value_cornerRadius_value_0_0);
+            }
+            else if (value_cornerRadius_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_cornerRadius_value_0_1 = value_cornerRadius_value_0.value1;
+                valueSerializer.writeNumber(value_cornerRadius_value_0_1);
+            }
+            else if (value_cornerRadius_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_cornerRadius_value_0_2 = value_cornerRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_cornerRadius_value_0_2);
+            }
         }
-        else if (value__bottom_value_type == 1) {
+        else if (value_cornerRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__bottom_value_1 = value__bottom_value.value1;
-            valueSerializer.writeNumber(value__bottom_value_1);
-        }
-        else if (value__bottom_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value__bottom_value_2 = value__bottom_value.value2;
-            Resource_serializer::write(valueSerializer, value__bottom_value_2);
+            const auto value_cornerRadius_value_1 = value_cornerRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_cornerRadius_value_1);
         }
     }
-    const auto value__start = value._start;
-    Ark_Int32 value__start_type = INTEROP_RUNTIME_UNDEFINED;
-    value__start_type = runtimeType(value__start);
-    valueSerializer.writeInt8(value__start_type);
-    if ((value__start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__start_value = value__start.value;
-        LengthMetrics_serializer::write(valueSerializer, value__start_value);
+    const auto value_isModal = value.isModal;
+    Ark_Int32 value_isModal_type = INTEROP_RUNTIME_UNDEFINED;
+    value_isModal_type = runtimeType(value_isModal);
+    valueSerializer.writeInt8(value_isModal_type);
+    if ((value_isModal_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_isModal_value = value_isModal.value;
+        valueSerializer.writeBoolean(value_isModal_value);
     }
-    const auto value__end = value._end;
-    Ark_Int32 value__end_type = INTEROP_RUNTIME_UNDEFINED;
-    value__end_type = runtimeType(value__end);
-    valueSerializer.writeInt8(value__end_type);
-    if ((value__end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__end_value = value__end.value;
-        LengthMetrics_serializer::write(valueSerializer, value__end_value);
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
     }
-    const auto value__fontColor = value._fontColor;
-    Ark_Int32 value__fontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value__fontColor_type = runtimeType(value__fontColor);
-    valueSerializer.writeInt8(value__fontColor_type);
-    if ((value__fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__fontColor_value = value__fontColor.value;
-        Ark_Int32 value__fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__fontColor_value_type = value__fontColor_value.selector;
-        if (value__fontColor_value_type == 0) {
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if (value_width_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__fontColor_value_0 = value__fontColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value__fontColor_value_0));
+            const auto value_width_value_0 = value_width_value.value0;
+            valueSerializer.writeString(value_width_value_0);
         }
-        else if (value__fontColor_value_type == 1) {
+        else if (value_width_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__fontColor_value_1 = value__fontColor_value.value1;
-            valueSerializer.writeNumber(value__fontColor_value_1);
+            const auto value_width_value_1 = value_width_value.value1;
+            valueSerializer.writeNumber(value_width_value_1);
         }
-        else if (value__fontColor_value_type == 2) {
+        else if (value_width_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value__fontColor_value_2 = value__fontColor_value.value2;
-            valueSerializer.writeString(value__fontColor_value_2);
-        }
-        else if (value__fontColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value__fontColor_value_3 = value__fontColor_value.value3;
-            Resource_serializer::write(valueSerializer, value__fontColor_value_3);
+            const auto value_width_value_2 = value_width_value.value2;
+            Resource_serializer::write(valueSerializer, value_width_value_2);
         }
     }
-    const auto value__selectedFontColor = value._selectedFontColor;
-    Ark_Int32 value__selectedFontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value__selectedFontColor_type = runtimeType(value__selectedFontColor);
-    valueSerializer.writeInt8(value__selectedFontColor_type);
-    if ((value__selectedFontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__selectedFontColor_value = value__selectedFontColor.value;
-        Ark_Int32 value__selectedFontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__selectedFontColor_value_type = value__selectedFontColor_value.selector;
-        if (value__selectedFontColor_value_type == 0) {
+    const auto value_height = value.height;
+    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
+    value_height_type = runtimeType(value_height);
+    valueSerializer.writeInt8(value_height_type);
+    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_height_value = value_height.value;
+        Ark_Int32 value_height_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_height_value_type = value_height_value.selector;
+        if (value_height_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__selectedFontColor_value_0 = value__selectedFontColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value__selectedFontColor_value_0));
+            const auto value_height_value_0 = value_height_value.value0;
+            valueSerializer.writeString(value_height_value_0);
         }
-        else if (value__selectedFontColor_value_type == 1) {
+        else if (value_height_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__selectedFontColor_value_1 = value__selectedFontColor_value.value1;
-            valueSerializer.writeNumber(value__selectedFontColor_value_1);
+            const auto value_height_value_1 = value_height_value.value1;
+            valueSerializer.writeNumber(value_height_value_1);
         }
-        else if (value__selectedFontColor_value_type == 2) {
+        else if (value_height_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value__selectedFontColor_value_2 = value__selectedFontColor_value.value2;
-            valueSerializer.writeString(value__selectedFontColor_value_2);
-        }
-        else if (value__selectedFontColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value__selectedFontColor_value_3 = value__selectedFontColor_value.value3;
-            Resource_serializer::write(valueSerializer, value__selectedFontColor_value_3);
+            const auto value_height_value_2 = value_height_value.value2;
+            Resource_serializer::write(valueSerializer, value_height_value_2);
         }
     }
-    const auto value__digitFont = value._digitFont;
-    Ark_Int32 value__digitFont_type = INTEROP_RUNTIME_UNDEFINED;
-    value__digitFont_type = runtimeType(value__digitFont);
-    valueSerializer.writeInt8(value__digitFont_type);
-    if ((value__digitFont_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__digitFont_value = value__digitFont.value;
-        Font_serializer::write(valueSerializer, value__digitFont_value);
-    }
-    const auto value__selectedDigitFont = value._selectedDigitFont;
-    Ark_Int32 value__selectedDigitFont_type = INTEROP_RUNTIME_UNDEFINED;
-    value__selectedDigitFont_type = runtimeType(value__selectedDigitFont);
-    valueSerializer.writeInt8(value__selectedDigitFont_type);
-    if ((value__selectedDigitFont_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__selectedDigitFont_value = value__selectedDigitFont.value;
-        Font_serializer::write(valueSerializer, value__selectedDigitFont_value);
-    }
-}
-inline Ark_DigitIndicator DigitIndicator_serializer::read(DeserializerBase& buffer)
-{
-    Ark_DigitIndicator value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto _left_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length _left_buf = {};
-    _left_buf.tag = _left_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_left_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _left_buf__selector = valueDeserializer.readInt8();
-        Ark_Length _left_buf_ = {};
-        _left_buf_.selector = _left_buf__selector;
-        if (_left_buf__selector == 0) {
-            _left_buf_.selector = 0;
-            _left_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (_left_buf__selector == 1) {
-            _left_buf_.selector = 1;
-            _left_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (_left_buf__selector == 2) {
-            _left_buf_.selector = 2;
-            _left_buf_.value2 = Resource_serializer::read(valueDeserializer);
+    const auto value_borderWidth = value.borderWidth;
+    Ark_Int32 value_borderWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderWidth_type = runtimeType(value_borderWidth);
+    valueSerializer.writeInt8(value_borderWidth_type);
+    if ((value_borderWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderWidth_value = value_borderWidth.value;
+        Ark_Int32 value_borderWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderWidth_value_type = value_borderWidth_value.selector;
+        if ((value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_borderWidth_value_0 = value_borderWidth_value.value0;
+            Ark_Int32 value_borderWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderWidth_value_0_type = value_borderWidth_value_0.selector;
+            if (value_borderWidth_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderWidth_value_0_0 = value_borderWidth_value_0.value0;
+                valueSerializer.writeString(value_borderWidth_value_0_0);
+            }
+            else if (value_borderWidth_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderWidth_value_0_1 = value_borderWidth_value_0.value1;
+                valueSerializer.writeNumber(value_borderWidth_value_0_1);
+            }
+            else if (value_borderWidth_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderWidth_value_0_2 = value_borderWidth_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderWidth_value_0_2);
+            }
         }
-        else {
-            INTEROP_FATAL("One of the branches for _left_buf_ has to be chosen through deserialisation.");
+        else if (value_borderWidth_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_borderWidth_value_1 = value_borderWidth_value.value1;
+            EdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_1);
         }
-        _left_buf.value = static_cast<Ark_Length>(_left_buf_);
     }
-    value._left = _left_buf;
-    const auto _top_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length _top_buf = {};
-    _top_buf.tag = _top_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_top_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _top_buf__selector = valueDeserializer.readInt8();
-        Ark_Length _top_buf_ = {};
-        _top_buf_.selector = _top_buf__selector;
-        if (_top_buf__selector == 0) {
-            _top_buf_.selector = 0;
-            _top_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (_top_buf__selector == 1) {
-            _top_buf_.selector = 1;
-            _top_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (_top_buf__selector == 2) {
-            _top_buf_.selector = 2;
-            _top_buf_.value2 = Resource_serializer::read(valueDeserializer);
+    const auto value_borderColor = value.borderColor;
+    Ark_Int32 value_borderColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderColor_type = runtimeType(value_borderColor);
+    valueSerializer.writeInt8(value_borderColor_type);
+    if ((value_borderColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderColor_value = value_borderColor.value;
+        Ark_Int32 value_borderColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderColor_value_type = value_borderColor_value.selector;
+        if ((value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_borderColor_value_0 = value_borderColor_value.value0;
+            Ark_Int32 value_borderColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderColor_value_0_type = value_borderColor_value_0.selector;
+            if (value_borderColor_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderColor_value_0_0 = value_borderColor_value_0.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_borderColor_value_0_0));
+            }
+            else if (value_borderColor_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderColor_value_0_1 = value_borderColor_value_0.value1;
+                valueSerializer.writeNumber(value_borderColor_value_0_1);
+            }
+            else if (value_borderColor_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderColor_value_0_2 = value_borderColor_value_0.value2;
+                valueSerializer.writeString(value_borderColor_value_0_2);
+            }
+            else if (value_borderColor_value_0_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_borderColor_value_0_3 = value_borderColor_value_0.value3;
+                Resource_serializer::write(valueSerializer, value_borderColor_value_0_3);
+            }
         }
-        else {
-            INTEROP_FATAL("One of the branches for _top_buf_ has to be chosen through deserialisation.");
+        else if (value_borderColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_borderColor_value_1 = value_borderColor_value.value1;
+            EdgeColors_serializer::write(valueSerializer, value_borderColor_value_1);
         }
-        _top_buf.value = static_cast<Ark_Length>(_top_buf_);
     }
-    value._top = _top_buf;
-    const auto _right_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length _right_buf = {};
-    _right_buf.tag = _right_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_right_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _right_buf__selector = valueDeserializer.readInt8();
-        Ark_Length _right_buf_ = {};
-        _right_buf_.selector = _right_buf__selector;
-        if (_right_buf__selector == 0) {
-            _right_buf_.selector = 0;
-            _right_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (_right_buf__selector == 1) {
-            _right_buf_.selector = 1;
-            _right_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (_right_buf__selector == 2) {
-            _right_buf_.selector = 2;
-            _right_buf_.value2 = Resource_serializer::read(valueDeserializer);
+    const auto value_borderStyle = value.borderStyle;
+    Ark_Int32 value_borderStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderStyle_type = runtimeType(value_borderStyle);
+    valueSerializer.writeInt8(value_borderStyle_type);
+    if ((value_borderStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderStyle_value = value_borderStyle.value;
+        Ark_Int32 value_borderStyle_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderStyle_value_type = value_borderStyle_value.selector;
+        if (value_borderStyle_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_borderStyle_value_0 = value_borderStyle_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_BorderStyle>(value_borderStyle_value_0));
         }
-        else {
-            INTEROP_FATAL("One of the branches for _right_buf_ has to be chosen through deserialisation.");
+        else if (value_borderStyle_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_borderStyle_value_1 = value_borderStyle_value.value1;
+            EdgeStyles_serializer::write(valueSerializer, value_borderStyle_value_1);
         }
-        _right_buf.value = static_cast<Ark_Length>(_right_buf_);
     }
-    value._right = _right_buf;
-    const auto _bottom_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length _bottom_buf = {};
-    _bottom_buf.tag = _bottom_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_bottom_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _bottom_buf__selector = valueDeserializer.readInt8();
-        Ark_Length _bottom_buf_ = {};
-        _bottom_buf_.selector = _bottom_buf__selector;
-        if (_bottom_buf__selector == 0) {
-            _bottom_buf_.selector = 0;
-            _bottom_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (_bottom_buf__selector == 1) {
-            _bottom_buf_.selector = 1;
-            _bottom_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (_bottom_buf__selector == 2) {
-            _bottom_buf_.selector = 2;
-            _bottom_buf_.value2 = Resource_serializer::read(valueDeserializer);
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
         }
-        else {
-            INTEROP_FATAL("One of the branches for _bottom_buf_ has to be chosen through deserialisation.");
+        else if (value_shadow_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
-        _bottom_buf.value = static_cast<Ark_Length>(_bottom_buf_);
     }
-    value._bottom = _bottom_buf;
-    const auto _start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LengthMetrics _start_buf = {};
-    _start_buf.tag = _start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _start_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
     }
-    value._start = _start_buf;
-    const auto _end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LengthMetrics _end_buf = {};
-    _end_buf.tag = _end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _end_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
+    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
+    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
+    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
+        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
     }
-    value._end = _end_buf;
-    const auto _fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor _fontColor_buf = {};
-    _fontColor_buf.tag = _fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _fontColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor _fontColor_buf_ = {};
-        _fontColor_buf_.selector = _fontColor_buf__selector;
-        if (_fontColor_buf__selector == 0) {
-            _fontColor_buf_.selector = 0;
-            _fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (_fontColor_buf__selector == 1) {
-            _fontColor_buf_.selector = 1;
-            _fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (_fontColor_buf__selector == 2) {
-            _fontColor_buf_.selector = 2;
-            _fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (_fontColor_buf__selector == 3) {
-            _fontColor_buf_.selector = 3;
-            _fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for _fontColor_buf_ has to be chosen through deserialisation.");
-        }
-        _fontColor_buf.value = static_cast<Ark_ResourceColor>(_fontColor_buf_);
+    const auto value_backgroundEffect = value.backgroundEffect;
+    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
+    valueSerializer.writeInt8(value_backgroundEffect_type);
+    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundEffect_value = value_backgroundEffect.value;
+        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
     }
-    value._fontColor = _fontColor_buf;
-    const auto _selectedFontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor _selectedFontColor_buf = {};
-    _selectedFontColor_buf.tag = _selectedFontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_selectedFontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _selectedFontColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor _selectedFontColor_buf_ = {};
-        _selectedFontColor_buf_.selector = _selectedFontColor_buf__selector;
-        if (_selectedFontColor_buf__selector == 0) {
-            _selectedFontColor_buf_.selector = 0;
-            _selectedFontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (_selectedFontColor_buf__selector == 1) {
-            _selectedFontColor_buf_.selector = 1;
-            _selectedFontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
+    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
+    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
+    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
+    }
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHoverMode_value = value_enableHoverMode.value;
+        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    }
+    const auto value_hoverModeArea = value.hoverModeArea;
+    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
+    valueSerializer.writeInt8(value_hoverModeArea_type);
+    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hoverModeArea_value = value_hoverModeArea.value;
+        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
+    }
+    const auto value_onDidAppear = value.onDidAppear;
+    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidAppear_type = runtimeType(value_onDidAppear);
+    valueSerializer.writeInt8(value_onDidAppear_type);
+    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidAppear_value = value_onDidAppear.value;
+        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
+    }
+    const auto value_onDidDisappear = value.onDidDisappear;
+    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
+    valueSerializer.writeInt8(value_onDidDisappear_type);
+    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidDisappear_value = value_onDidDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
+    }
+    const auto value_onWillAppear = value.onWillAppear;
+    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillAppear_type = runtimeType(value_onWillAppear);
+    valueSerializer.writeInt8(value_onWillAppear_type);
+    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillAppear_value = value_onWillAppear.value;
+        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    }
+    const auto value_onWillDisappear = value.onWillDisappear;
+    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
+    valueSerializer.writeInt8(value_onWillDisappear_type);
+    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDisappear_value = value_onWillDisappear.value;
+        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    }
+    const auto value_keyboardAvoidDistance = value.keyboardAvoidDistance;
+    Ark_Int32 value_keyboardAvoidDistance_type = INTEROP_RUNTIME_UNDEFINED;
+    value_keyboardAvoidDistance_type = runtimeType(value_keyboardAvoidDistance);
+    valueSerializer.writeInt8(value_keyboardAvoidDistance_type);
+    if ((value_keyboardAvoidDistance_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_keyboardAvoidDistance_value = value_keyboardAvoidDistance.value;
+        LengthMetrics_serializer::write(valueSerializer, value_keyboardAvoidDistance_value);
+    }
+    const auto value_levelMode = value.levelMode;
+    Ark_Int32 value_levelMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_levelMode_type = runtimeType(value_levelMode);
+    valueSerializer.writeInt8(value_levelMode_type);
+    if ((value_levelMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_levelMode_value = value_levelMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_LevelMode>(value_levelMode_value));
+    }
+    const auto value_levelUniqueId = value.levelUniqueId;
+    Ark_Int32 value_levelUniqueId_type = INTEROP_RUNTIME_UNDEFINED;
+    value_levelUniqueId_type = runtimeType(value_levelUniqueId);
+    valueSerializer.writeInt8(value_levelUniqueId_type);
+    if ((value_levelUniqueId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_levelUniqueId_value = value_levelUniqueId.value;
+        valueSerializer.writeNumber(value_levelUniqueId_value);
+    }
+    const auto value_immersiveMode = value.immersiveMode;
+    Ark_Int32 value_immersiveMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_immersiveMode_type = runtimeType(value_immersiveMode);
+    valueSerializer.writeInt8(value_immersiveMode_type);
+    if ((value_immersiveMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_immersiveMode_value = value_immersiveMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImmersiveMode>(value_immersiveMode_value));
+    }
+    const auto value_levelOrder = value.levelOrder;
+    Ark_Int32 value_levelOrder_type = INTEROP_RUNTIME_UNDEFINED;
+    value_levelOrder_type = runtimeType(value_levelOrder);
+    valueSerializer.writeInt8(value_levelOrder_type);
+    if ((value_levelOrder_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_levelOrder_value = value_levelOrder.value;
+        LevelOrder_serializer::write(valueSerializer, value_levelOrder_value);
+    }
+    const auto value_focusable = value.focusable;
+    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusable_type = runtimeType(value_focusable);
+    valueSerializer.writeInt8(value_focusable_type);
+    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusable_value = value_focusable.value;
+        valueSerializer.writeBoolean(value_focusable_value);
+    }
+}
+inline Ark_CustomDialogControllerOptions CustomDialogControllerOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_CustomDialogControllerOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const Ark_Int8 builder_buf_selector = valueDeserializer.readInt8();
+    Ark_Union_CustomBuilder_ExtendableComponent builder_buf = {};
+    builder_buf.selector = builder_buf_selector;
+    if (builder_buf_selector == 0) {
+        builder_buf.selector = 0;
+        builder_buf.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+    }
+    else if (builder_buf_selector == 1) {
+        builder_buf.selector = 1;
+        builder_buf.value1 = static_cast<Ark_ExtendableComponent>(ExtendableComponent_serializer::read(valueDeserializer));
+    }
+    else {
+        INTEROP_FATAL("One of the branches for builder_buf has to be chosen through deserialisation.");
+    }
+    value.builder = static_cast<Ark_Union_CustomBuilder_ExtendableComponent>(builder_buf);
+    const auto cancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void cancel_buf = {};
+    cancel_buf.tag = cancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((cancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        cancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.cancel = cancel_buf;
+    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean autoCancel_buf = {};
+    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        autoCancel_buf.value = valueDeserializer.readBoolean();
+    }
+    value.autoCancel = autoCancel_buf;
+    const auto alignment_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_DialogAlignment alignment_buf = {};
+    alignment_buf.tag = alignment_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((alignment_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        alignment_buf.value = static_cast<Ark_DialogAlignment>(valueDeserializer.readInt32());
+    }
+    value.alignment = alignment_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Offset offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offset_buf.value = Offset_serializer::read(valueDeserializer);
+    }
+    value.offset = offset_buf;
+    const auto customStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean customStyle_buf = {};
+    customStyle_buf.tag = customStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((customStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        customStyle_buf.value = valueDeserializer.readBoolean();
+    }
+    value.customStyle = customStyle_buf;
+    const auto gridCount_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number gridCount_buf = {};
+    gridCount_buf.tag = gridCount_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((gridCount_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        gridCount_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    value.gridCount = gridCount_buf;
+    const auto maskColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor maskColor_buf = {};
+    maskColor_buf.tag = maskColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maskColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 maskColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor maskColor_buf_ = {};
+        maskColor_buf_.selector = maskColor_buf__selector;
+        if (maskColor_buf__selector == 0) {
+            maskColor_buf_.selector = 0;
+            maskColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (_selectedFontColor_buf__selector == 2) {
-            _selectedFontColor_buf_.selector = 2;
-            _selectedFontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (maskColor_buf__selector == 1) {
+            maskColor_buf_.selector = 1;
+            maskColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (_selectedFontColor_buf__selector == 3) {
-            _selectedFontColor_buf_.selector = 3;
-            _selectedFontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (maskColor_buf__selector == 2) {
+            maskColor_buf_.selector = 2;
+            maskColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (maskColor_buf__selector == 3) {
+            maskColor_buf_.selector = 3;
+            maskColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for _selectedFontColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for maskColor_buf_ has to be chosen through deserialisation.");
         }
-        _selectedFontColor_buf.value = static_cast<Ark_ResourceColor>(_selectedFontColor_buf_);
+        maskColor_buf.value = static_cast<Ark_ResourceColor>(maskColor_buf_);
     }
-    value._selectedFontColor = _selectedFontColor_buf;
-    const auto _digitFont_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font _digitFont_buf = {};
-    _digitFont_buf.tag = _digitFont_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_digitFont_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maskColor = maskColor_buf;
+    const auto maskRect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Rectangle maskRect_buf = {};
+    maskRect_buf.tag = maskRect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maskRect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _digitFont_buf.value = Font_serializer::read(valueDeserializer);
+        maskRect_buf.value = Rectangle_serializer::read(valueDeserializer);
     }
-    value._digitFont = _digitFont_buf;
-    const auto _selectedDigitFont_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font _selectedDigitFont_buf = {};
-    _selectedDigitFont_buf.tag = _selectedDigitFont_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_selectedDigitFont_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maskRect = maskRect_buf;
+    const auto openAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_AnimateParam openAnimation_buf = {};
+    openAnimation_buf.tag = openAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((openAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _selectedDigitFont_buf.value = Font_serializer::read(valueDeserializer);
+        openAnimation_buf.value = AnimateParam_serializer::read(valueDeserializer);
     }
-    value._selectedDigitFont = _selectedDigitFont_buf;
-    return value;
-}
-inline void EventTarget_serializer::write(SerializerBase& buffer, Ark_EventTarget value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_area = value.area;
-    Area_serializer::write(valueSerializer, value_area);
-    const auto value_id = value.id;
-    Ark_Int32 value_id_type = INTEROP_RUNTIME_UNDEFINED;
-    value_id_type = runtimeType(value_id);
-    valueSerializer.writeInt8(value_id_type);
-    if ((value_id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_id_value = value_id.value;
-        valueSerializer.writeString(value_id_value);
+    value.openAnimation = openAnimation_buf;
+    const auto closeAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_AnimateParam closeAnimation_buf = {};
+    closeAnimation_buf.tag = closeAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((closeAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        closeAnimation_buf.value = AnimateParam_serializer::read(valueDeserializer);
     }
-}
-inline Ark_EventTarget EventTarget_serializer::read(DeserializerBase& buffer)
-{
-    Ark_EventTarget value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.area = Area_serializer::read(valueDeserializer);
-    const auto id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String id_buf = {};
-    id_buf.tag = id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.closeAnimation = closeAnimation_buf;
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
     }
-    value.id = id_buf;
-    return value;
-}
-inline void FocusAxisEvent_serializer::write(SerializerBase& buffer, Ark_FocusAxisEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_FocusAxisEvent FocusAxisEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_FocusAxisEvent>(ptr);
-}
-inline void GeometryInfo_serializer::write(SerializerBase& buffer, Ark_GeometryInfo value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_width = value.width;
-    valueSerializer.writeNumber(value_width);
-    const auto value_height = value.height;
-    valueSerializer.writeNumber(value_height);
-    const auto value_borderWidth = value.borderWidth;
-    EdgeWidths_serializer::write(valueSerializer, value_borderWidth);
-    const auto value_margin = value.margin;
-    Padding_serializer::write(valueSerializer, value_margin);
-    const auto value_padding = value.padding;
-    Padding_serializer::write(valueSerializer, value_padding);
-}
-inline Ark_GeometryInfo GeometryInfo_serializer::read(DeserializerBase& buffer)
-{
-    Ark_GeometryInfo value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.width = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.height = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.borderWidth = EdgeWidths_serializer::read(valueDeserializer);
-    value.margin = Padding_serializer::read(valueDeserializer);
-    value.padding = Padding_serializer::read(valueDeserializer);
-    return value;
-}
-inline void GestureEvent_serializer::write(SerializerBase& buffer, Ark_GestureEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_GestureEvent GestureEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_GestureEvent>(ptr);
-}
-inline void GutterOption_serializer::write(SerializerBase& buffer, Ark_GutterOption value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_x = value.x;
-    Ark_Int32 value_x_type = INTEROP_RUNTIME_UNDEFINED;
-    value_x_type = runtimeType(value_x);
-    valueSerializer.writeInt8(value_x_type);
-    if ((value_x_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_x_value = value_x.value;
-        Ark_Int32 value_x_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_x_value_type = value_x_value.selector;
-        if ((value_x_value_type == 0) || (value_x_value_type == 0) || (value_x_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_x_value_0 = value_x_value.value0;
-            Ark_Int32 value_x_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_x_value_0_type = value_x_value_0.selector;
-            if (value_x_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_x_value_0_0 = value_x_value_0.value0;
-                valueSerializer.writeString(value_x_value_0_0);
-            }
-            else if (value_x_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_x_value_0_1 = value_x_value_0.value1;
-                valueSerializer.writeNumber(value_x_value_0_1);
-            }
-            else if (value_x_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_x_value_0_2 = value_x_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_x_value_0_2);
-            }
+    value.showInSubWindow = showInSubWindow_buf;
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (value_x_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_x_value_1 = value_x_value.value1;
-            GridRowSizeOption_serializer::write(valueSerializer, value_x_value_1);
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-    }
-    const auto value_y = value.y;
-    Ark_Int32 value_y_type = INTEROP_RUNTIME_UNDEFINED;
-    value_y_type = runtimeType(value_y);
-    valueSerializer.writeInt8(value_y_type);
-    if ((value_y_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_y_value = value_y.value;
-        Ark_Int32 value_y_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_y_value_type = value_y_value.selector;
-        if ((value_y_value_type == 0) || (value_y_value_type == 0) || (value_y_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_y_value_0 = value_y_value.value0;
-            Ark_Int32 value_y_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_y_value_0_type = value_y_value_0.selector;
-            if (value_y_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_y_value_0_0 = value_y_value_0.value0;
-                valueSerializer.writeString(value_y_value_0_0);
-            }
-            else if (value_y_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_y_value_0_1 = value_y_value_0.value1;
-                valueSerializer.writeNumber(value_y_value_0_1);
-            }
-            else if (value_y_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_y_value_0_2 = value_y_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_y_value_0_2);
-            }
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (value_y_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_y_value_1 = value_y_value.value1;
-            GridRowSizeOption_serializer::write(valueSerializer, value_y_value_1);
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
         }
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-}
-inline Ark_GutterOption GutterOption_serializer::read(DeserializerBase& buffer)
-{
-    Ark_GutterOption value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto x_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_GridRowSizeOption x_buf = {};
-    x_buf.tag = x_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((x_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundColor = backgroundColor_buf;
+    const auto cornerRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_BorderRadiuses cornerRadius_buf = {};
+    cornerRadius_buf.tag = cornerRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((cornerRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 x_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_GridRowSizeOption x_buf_ = {};
-        x_buf_.selector = x_buf__selector;
-        if (x_buf__selector == 0) {
-            x_buf_.selector = 0;
-            const Ark_Int8 x_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length x_buf__u = {};
-            x_buf__u.selector = x_buf__u_selector;
-            if (x_buf__u_selector == 0) {
-                x_buf__u.selector = 0;
-                x_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 cornerRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_BorderRadiuses cornerRadius_buf_ = {};
+        cornerRadius_buf_.selector = cornerRadius_buf__selector;
+        if (cornerRadius_buf__selector == 0) {
+            cornerRadius_buf_.selector = 0;
+            const Ark_Int8 cornerRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension cornerRadius_buf__u = {};
+            cornerRadius_buf__u.selector = cornerRadius_buf__u_selector;
+            if (cornerRadius_buf__u_selector == 0) {
+                cornerRadius_buf__u.selector = 0;
+                cornerRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (x_buf__u_selector == 1) {
-                x_buf__u.selector = 1;
-                x_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (cornerRadius_buf__u_selector == 1) {
+                cornerRadius_buf__u.selector = 1;
+                cornerRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (x_buf__u_selector == 2) {
-                x_buf__u.selector = 2;
-                x_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (cornerRadius_buf__u_selector == 2) {
+                cornerRadius_buf__u.selector = 2;
+                cornerRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for x_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for cornerRadius_buf__u has to be chosen through deserialisation.");
             }
-            x_buf_.value0 = static_cast<Ark_Length>(x_buf__u);
+            cornerRadius_buf_.value0 = static_cast<Ark_Dimension>(cornerRadius_buf__u);
         }
-        else if (x_buf__selector == 1) {
-            x_buf_.selector = 1;
-            x_buf_.value1 = GridRowSizeOption_serializer::read(valueDeserializer);
+        else if (cornerRadius_buf__selector == 1) {
+            cornerRadius_buf_.selector = 1;
+            cornerRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for x_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for cornerRadius_buf_ has to be chosen through deserialisation.");
         }
-        x_buf.value = static_cast<Ark_Union_Length_GridRowSizeOption>(x_buf_);
+        cornerRadius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(cornerRadius_buf_);
     }
-    value.x = x_buf;
-    const auto y_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_GridRowSizeOption y_buf = {};
-    y_buf.tag = y_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((y_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.cornerRadius = cornerRadius_buf;
+    const auto isModal_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean isModal_buf = {};
+    isModal_buf.tag = isModal_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((isModal_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 y_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_GridRowSizeOption y_buf_ = {};
-        y_buf_.selector = y_buf__selector;
-        if (y_buf__selector == 0) {
-            y_buf_.selector = 0;
-            const Ark_Int8 y_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length y_buf__u = {};
-            y_buf__u.selector = y_buf__u_selector;
-            if (y_buf__u_selector == 0) {
-                y_buf__u.selector = 0;
-                y_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (y_buf__u_selector == 1) {
-                y_buf__u.selector = 1;
-                y_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (y_buf__u_selector == 2) {
-                y_buf__u.selector = 2;
-                y_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for y_buf__u has to be chosen through deserialisation.");
-            }
-            y_buf_.value0 = static_cast<Ark_Length>(y_buf__u);
-        }
-        else if (y_buf__selector == 1) {
-            y_buf_.selector = 1;
-            y_buf_.value1 = GridRowSizeOption_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for y_buf_ has to be chosen through deserialisation.");
-        }
-        y_buf.value = static_cast<Ark_Union_Length_GridRowSizeOption>(y_buf_);
-    }
-    value.y = y_buf;
-    return value;
-}
-inline void HoverEvent_serializer::write(SerializerBase& buffer, Ark_HoverEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_HoverEvent HoverEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_HoverEvent>(ptr);
-}
-inline void ImageAttachmentLayoutStyle_serializer::write(SerializerBase& buffer, Ark_ImageAttachmentLayoutStyle value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_margin = value.margin;
-    Ark_Int32 value_margin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_margin_type = runtimeType(value_margin);
-    valueSerializer.writeInt8(value_margin_type);
-    if ((value_margin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_margin_value = value_margin.value;
-        Ark_Int32 value_margin_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_margin_value_type = value_margin_value.selector;
-        if (value_margin_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_margin_value_0 = value_margin_value.value0;
-            LengthMetrics_serializer::write(valueSerializer, value_margin_value_0);
-        }
-        else if (value_margin_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_margin_value_1 = value_margin_value.value1;
-            Padding_serializer::write(valueSerializer, value_margin_value_1);
-        }
-    }
-    const auto value_padding = value.padding;
-    Ark_Int32 value_padding_type = INTEROP_RUNTIME_UNDEFINED;
-    value_padding_type = runtimeType(value_padding);
-    valueSerializer.writeInt8(value_padding_type);
-    if ((value_padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_padding_value = value_padding.value;
-        Ark_Int32 value_padding_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_padding_value_type = value_padding_value.selector;
-        if (value_padding_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_padding_value_0 = value_padding_value.value0;
-            LengthMetrics_serializer::write(valueSerializer, value_padding_value_0);
-        }
-        else if (value_padding_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_padding_value_1 = value_padding_value.value1;
-            Padding_serializer::write(valueSerializer, value_padding_value_1);
-        }
-    }
-    const auto value_borderRadius = value.borderRadius;
-    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderRadius_type = runtimeType(value_borderRadius);
-    valueSerializer.writeInt8(value_borderRadius_type);
-    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderRadius_value = value_borderRadius.value;
-        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderRadius_value_type = value_borderRadius_value.selector;
-        if (value_borderRadius_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
-            LengthMetrics_serializer::write(valueSerializer, value_borderRadius_value_0);
-        }
-        else if (value_borderRadius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
-        }
+        isModal_buf.value = valueDeserializer.readBoolean();
     }
-}
-inline Ark_ImageAttachmentLayoutStyle ImageAttachmentLayoutStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_ImageAttachmentLayoutStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto margin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_LengthMetrics_Margin margin_buf = {};
-    margin_buf.tag = margin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((margin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.isModal = isModal_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_DismissDialogAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 margin_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_LengthMetrics_Margin margin_buf_ = {};
-        margin_buf_.selector = margin_buf__selector;
-        if (margin_buf__selector == 0) {
-            margin_buf_.selector = 0;
-            margin_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
-        }
-        else if (margin_buf__selector == 1) {
-            margin_buf_.selector = 1;
-            margin_buf_.value1 = Padding_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for margin_buf_ has to be chosen through deserialisation.");
-        }
-        margin_buf.value = static_cast<Ark_Union_LengthMetrics_Margin>(margin_buf_);
+        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissDialogAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissDialogAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissDialogAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissDialogAction_Void))))};
     }
-    value.margin = margin_buf;
-    const auto padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_LengthMetrics_Padding padding_buf = {};
-    padding_buf.tag = padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillDismiss = onWillDismiss_buf;
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 padding_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_LengthMetrics_Padding padding_buf_ = {};
-        padding_buf_.selector = padding_buf__selector;
-        if (padding_buf__selector == 0) {
-            padding_buf_.selector = 0;
-            padding_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension width_buf_ = {};
+        width_buf_.selector = width_buf__selector;
+        if (width_buf__selector == 0) {
+            width_buf_.selector = 0;
+            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (padding_buf__selector == 1) {
-            padding_buf_.selector = 1;
-            padding_buf_.value1 = Padding_serializer::read(valueDeserializer);
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (width_buf__selector == 2) {
+            width_buf_.selector = 2;
+            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for padding_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
         }
-        padding_buf.value = static_cast<Ark_Union_LengthMetrics_Padding>(padding_buf_);
+        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
     }
-    value.padding = padding_buf;
-    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_LengthMetrics_BorderRadiuses borderRadius_buf = {};
-    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.width = width_buf;
+    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension height_buf = {};
+    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_LengthMetrics_BorderRadiuses borderRadius_buf_ = {};
-        borderRadius_buf_.selector = borderRadius_buf__selector;
-        if (borderRadius_buf__selector == 0) {
-            borderRadius_buf_.selector = 0;
-            borderRadius_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
-        }
-        else if (borderRadius_buf__selector == 1) {
-            borderRadius_buf_.selector = 1;
-            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        const Ark_Int8 height_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension height_buf_ = {};
+        height_buf_.selector = height_buf__selector;
+        if (height_buf__selector == 0) {
+            height_buf_.selector = 0;
+            height_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else {
-            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
+        else if (height_buf__selector == 1) {
+            height_buf_.selector = 1;
+            height_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        borderRadius_buf.value = static_cast<Ark_Union_LengthMetrics_BorderRadiuses>(borderRadius_buf_);
-    }
-    value.borderRadius = borderRadius_buf;
-    return value;
-}
-inline void LayoutChild_serializer::write(SerializerBase& buffer, Ark_LayoutChild value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_LayoutChild LayoutChild_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_LayoutChild>(ptr);
-}
-inline void LongPressGestureEvent_serializer::write(SerializerBase& buffer, Ark_LongPressGestureEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_LongPressGestureEvent LongPressGestureEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_LongPressGestureEvent>(ptr);
-}
-inline void MenuOutlineOptions_serializer::write(SerializerBase& buffer, Ark_MenuOutlineOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if ((value_width_value_type == 0) || (value_width_value_type == 0) || (value_width_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            Ark_Int32 value_width_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_width_value_0_type = value_width_value_0.selector;
-            if (value_width_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_width_value_0_0 = value_width_value_0.value0;
-                valueSerializer.writeString(value_width_value_0_0);
-            }
-            else if (value_width_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_width_value_0_1 = value_width_value_0.value1;
-                valueSerializer.writeNumber(value_width_value_0_1);
-            }
-            else if (value_width_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_width_value_0_2 = value_width_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_width_value_0_2);
-            }
+        else if (height_buf__selector == 2) {
+            height_buf_.selector = 2;
+            height_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
-        else if (value_width_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            EdgeOutlineWidths_serializer::write(valueSerializer, value_width_value_1);
+        else {
+            INTEROP_FATAL("One of the branches for height_buf_ has to be chosen through deserialisation.");
         }
+        height_buf.value = static_cast<Ark_Dimension>(height_buf_);
     }
-    const auto value_color = value.color;
-    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
-    value_color_type = runtimeType(value_color);
-    valueSerializer.writeInt8(value_color_type);
-    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_color_value = value_color.value;
-        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_color_value_type = value_color_value.selector;
-        if ((value_color_value_type == 0) || (value_color_value_type == 0) || (value_color_value_type == 0) || (value_color_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_color_value_0 = value_color_value.value0;
-            Ark_Int32 value_color_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_color_value_0_type = value_color_value_0.selector;
-            if (value_color_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_color_value_0_0 = value_color_value_0.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0_0));
+    value.height = height_buf;
+    const auto borderWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_EdgeWidths borderWidth_buf = {};
+    borderWidth_buf.tag = borderWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_EdgeWidths borderWidth_buf_ = {};
+        borderWidth_buf_.selector = borderWidth_buf__selector;
+        if (borderWidth_buf__selector == 0) {
+            borderWidth_buf_.selector = 0;
+            const Ark_Int8 borderWidth_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension borderWidth_buf__u = {};
+            borderWidth_buf__u.selector = borderWidth_buf__u_selector;
+            if (borderWidth_buf__u_selector == 0) {
+                borderWidth_buf__u.selector = 0;
+                borderWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (value_color_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_color_value_0_1 = value_color_value_0.value1;
-                valueSerializer.writeNumber(value_color_value_0_1);
+            else if (borderWidth_buf__u_selector == 1) {
+                borderWidth_buf__u.selector = 1;
+                borderWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (value_color_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_color_value_0_2 = value_color_value_0.value2;
-                valueSerializer.writeString(value_color_value_0_2);
+            else if (borderWidth_buf__u_selector == 2) {
+                borderWidth_buf__u.selector = 2;
+                borderWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
-            else if (value_color_value_0_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_color_value_0_3 = value_color_value_0.value3;
-                Resource_serializer::write(valueSerializer, value_color_value_0_3);
+            else {
+                INTEROP_FATAL("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.");
             }
+            borderWidth_buf_.value0 = static_cast<Ark_Dimension>(borderWidth_buf__u);
         }
-        else if (value_color_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_color_value_1 = value_color_value.value1;
-            EdgeColors_serializer::write(valueSerializer, value_color_value_1);
+        else if (borderWidth_buf__selector == 1) {
+            borderWidth_buf_.selector = 1;
+            borderWidth_buf_.value1 = EdgeWidths_serializer::read(valueDeserializer);
         }
+        else {
+            INTEROP_FATAL("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.");
+        }
+        borderWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeWidths>(borderWidth_buf_);
     }
-}
-inline Ark_MenuOutlineOptions MenuOutlineOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_MenuOutlineOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_EdgeOutlineWidths width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.borderWidth = borderWidth_buf;
+    const auto borderColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceColor_EdgeColors borderColor_buf = {};
+    borderColor_buf.tag = borderColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_EdgeOutlineWidths width_buf_ = {};
-        width_buf_.selector = width_buf__selector;
-        if (width_buf__selector == 0) {
-            width_buf_.selector = 0;
-            const Ark_Int8 width_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension width_buf__u = {};
-            width_buf__u.selector = width_buf__u_selector;
-            if (width_buf__u_selector == 0) {
-                width_buf__u.selector = 0;
-                width_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 borderColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceColor_EdgeColors borderColor_buf_ = {};
+        borderColor_buf_.selector = borderColor_buf__selector;
+        if (borderColor_buf__selector == 0) {
+            borderColor_buf_.selector = 0;
+            const Ark_Int8 borderColor_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor borderColor_buf__u = {};
+            borderColor_buf__u.selector = borderColor_buf__u_selector;
+            if (borderColor_buf__u_selector == 0) {
+                borderColor_buf__u.selector = 0;
+                borderColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
             }
-            else if (width_buf__u_selector == 1) {
-                width_buf__u.selector = 1;
-                width_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (borderColor_buf__u_selector == 1) {
+                borderColor_buf__u.selector = 1;
+                borderColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (width_buf__u_selector == 2) {
-                width_buf__u.selector = 2;
-                width_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (borderColor_buf__u_selector == 2) {
+                borderColor_buf__u.selector = 2;
+                borderColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderColor_buf__u_selector == 3) {
+                borderColor_buf__u.selector = 3;
+                borderColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for width_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for borderColor_buf__u has to be chosen through deserialisation.");
             }
-            width_buf_.value0 = static_cast<Ark_Dimension>(width_buf__u);
+            borderColor_buf_.value0 = static_cast<Ark_ResourceColor>(borderColor_buf__u);
         }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+        else if (borderColor_buf__selector == 1) {
+            borderColor_buf_.selector = 1;
+            borderColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for borderColor_buf_ has to be chosen through deserialisation.");
         }
-        width_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(width_buf_);
+        borderColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(borderColor_buf_);
     }
-    value.width = width_buf;
-    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceColor_EdgeColors color_buf = {};
-    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.borderColor = borderColor_buf;
+    const auto borderStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_BorderStyle_EdgeStyles borderStyle_buf = {};
+    borderStyle_buf.tag = borderStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceColor_EdgeColors color_buf_ = {};
-        color_buf_.selector = color_buf__selector;
-        if (color_buf__selector == 0) {
-            color_buf_.selector = 0;
-            const Ark_Int8 color_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor color_buf__u = {};
-            color_buf__u.selector = color_buf__u_selector;
-            if (color_buf__u_selector == 0) {
-                color_buf__u.selector = 0;
-                color_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-            }
-            else if (color_buf__u_selector == 1) {
-                color_buf__u.selector = 1;
-                color_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (color_buf__u_selector == 2) {
-                color_buf__u.selector = 2;
-                color_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (color_buf__u_selector == 3) {
-                color_buf__u.selector = 3;
-                color_buf__u.value3 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for color_buf__u has to be chosen through deserialisation.");
-            }
-            color_buf_.value0 = static_cast<Ark_ResourceColor>(color_buf__u);
+        const Ark_Int8 borderStyle_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_BorderStyle_EdgeStyles borderStyle_buf_ = {};
+        borderStyle_buf_.selector = borderStyle_buf__selector;
+        if (borderStyle_buf__selector == 0) {
+            borderStyle_buf_.selector = 0;
+            borderStyle_buf_.value0 = static_cast<Ark_BorderStyle>(valueDeserializer.readInt32());
         }
-        else if (color_buf__selector == 1) {
-            color_buf_.selector = 1;
-            color_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
+        else if (borderStyle_buf__selector == 1) {
+            borderStyle_buf_.selector = 1;
+            borderStyle_buf_.value1 = EdgeStyles_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.");
         }
-        color_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(color_buf_);
+        borderStyle_buf.value = static_cast<Ark_Union_BorderStyle_EdgeStyles>(borderStyle_buf_);
     }
-    value.color = color_buf;
-    return value;
-}
-inline void MouseEvent_serializer::write(SerializerBase& buffer, Ark_MouseEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_MouseEvent MouseEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_MouseEvent>(ptr);
-}
-inline void NativeEmbedInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedInfo value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_id = value.id;
-    Ark_Int32 value_id_type = INTEROP_RUNTIME_UNDEFINED;
-    value_id_type = runtimeType(value_id);
-    valueSerializer.writeInt8(value_id_type);
-    if ((value_id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_id_value = value_id.value;
-        valueSerializer.writeString(value_id_value);
+    value.borderStyle = borderStyle_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        }
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+        }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
-    const auto value_type = value.type;
-    Ark_Int32 value_type_type = INTEROP_RUNTIME_UNDEFINED;
-    value_type_type = runtimeType(value_type);
-    valueSerializer.writeInt8(value_type_type);
-    if ((value_type_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_type_value = value_type.value;
-        valueSerializer.writeString(value_type_value);
+    value.shadow = shadow_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    const auto value_src = value.src;
-    Ark_Int32 value_src_type = INTEROP_RUNTIME_UNDEFINED;
-    value_src_type = runtimeType(value_src);
-    valueSerializer.writeInt8(value_src_type);
-    if ((value_src_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_src_value = value_src.value;
-        valueSerializer.writeString(value_src_value);
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
+    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
     }
-    const auto value_position = value.position;
-    Ark_Int32 value_position_type = INTEROP_RUNTIME_UNDEFINED;
-    value_position_type = runtimeType(value_position);
-    valueSerializer.writeInt8(value_position_type);
-    if ((value_position_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_position_value = value_position.value;
-        Position_serializer::write(valueSerializer, value_position_value);
-    }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        valueSerializer.writeInt32(value_width_value);
-    }
-    const auto value_height = value.height;
-    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
-    value_height_type = runtimeType(value_height);
-    valueSerializer.writeInt8(value_height_type);
-    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_height_value = value_height.value;
-        valueSerializer.writeInt32(value_height_value);
-    }
-    const auto value_url = value.url;
-    Ark_Int32 value_url_type = INTEROP_RUNTIME_UNDEFINED;
-    value_url_type = runtimeType(value_url);
-    valueSerializer.writeInt8(value_url_type);
-    if ((value_url_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_url_value = value_url.value;
-        valueSerializer.writeString(value_url_value);
+    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
+    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
+    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
     }
-    const auto value_tag = value.tag;
-    Ark_Int32 value_tag_type = INTEROP_RUNTIME_UNDEFINED;
-    value_tag_type = runtimeType(value_tag);
-    valueSerializer.writeInt8(value_tag_type);
-    if ((value_tag_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_tag_value = value_tag.value;
-        valueSerializer.writeString(value_tag_value);
+    value.backgroundEffect = backgroundEffect_buf;
+    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
+    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
     }
-    const auto value_params = value.params;
-    Ark_Int32 value_params_type = INTEROP_RUNTIME_UNDEFINED;
-    value_params_type = runtimeType(value_params);
-    valueSerializer.writeInt8(value_params_type);
-    if ((value_params_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_params_value = value_params.value;
-        valueSerializer.writeInt32(value_params_value.size);
-        for (int32_t i = 0; i < value_params_value.size; i++) {
-            auto value_params_value_key = value_params_value.keys[i];
-            auto value_params_value_value = value_params_value.values[i];
-            valueSerializer.writeString(value_params_value_key);
-            valueSerializer.writeString(value_params_value_value);
-        }
+    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
-}
-inline Ark_NativeEmbedInfo NativeEmbedInfo_serializer::read(DeserializerBase& buffer)
-{
-    Ark_NativeEmbedInfo value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String id_buf = {};
-    id_buf.tag = id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HoverModeAreaType hoverModeArea_buf = {};
+    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
     }
-    value.id = id_buf;
-    const auto type_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String type_buf = {};
-    type_buf.tag = type_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((type_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.hoverModeArea = hoverModeArea_buf;
+    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDidAppear_buf = {};
+    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        type_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.type = type_buf;
-    const auto src_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String src_buf = {};
-    src_buf.tag = src_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((src_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onDidAppear = onDidAppear_buf;
+    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDidDisappear_buf = {};
+    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        src_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.src = src_buf;
-    const auto position_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position position_buf = {};
-    position_buf.tag = position_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((position_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onDidDisappear = onDidDisappear_buf;
+    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillAppear_buf = {};
+    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        position_buf.value = Position_serializer::read(valueDeserializer);
+        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.position = position_buf;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Int32 width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillAppear = onWillAppear_buf;
+    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillDisappear_buf = {};
+    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        width_buf.value = valueDeserializer.readInt32();
+        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.width = width_buf;
-    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Int32 height_buf = {};
-    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillDisappear = onWillDisappear_buf;
+    const auto keyboardAvoidDistance_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LengthMetrics keyboardAvoidDistance_buf = {};
+    keyboardAvoidDistance_buf.tag = keyboardAvoidDistance_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((keyboardAvoidDistance_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        height_buf.value = valueDeserializer.readInt32();
+        keyboardAvoidDistance_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
     }
-    value.height = height_buf;
-    const auto url_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String url_buf = {};
-    url_buf.tag = url_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((url_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.keyboardAvoidDistance = keyboardAvoidDistance_buf;
+    const auto levelMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LevelMode levelMode_buf = {};
+    levelMode_buf.tag = levelMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((levelMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        url_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        levelMode_buf.value = static_cast<Ark_LevelMode>(valueDeserializer.readInt32());
     }
-    value.url = url_buf;
-    const auto tag_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String tag_buf = {};
-    tag_buf.tag = tag_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((tag_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.levelMode = levelMode_buf;
+    const auto levelUniqueId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number levelUniqueId_buf = {};
+    levelUniqueId_buf.tag = levelUniqueId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((levelUniqueId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        tag_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        levelUniqueId_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.tag = tag_buf;
-    const auto params_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Map_String_String params_buf = {};
-    params_buf.tag = params_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((params_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.levelUniqueId = levelUniqueId_buf;
+    const auto immersiveMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImmersiveMode immersiveMode_buf = {};
+    immersiveMode_buf.tag = immersiveMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((immersiveMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int32 params_buf__size = valueDeserializer.readInt32();
-        Map_String_String params_buf_ = {};
-        valueDeserializer.resizeMap<Map_String_String, Ark_String, Ark_String>(&params_buf_, params_buf__size);
-        for (int params_buf__i = 0; params_buf__i < params_buf__size; params_buf__i++) {
-            const Ark_String params_buf__key = static_cast<Ark_String>(valueDeserializer.readString());
-            const Ark_String params_buf__value = static_cast<Ark_String>(valueDeserializer.readString());
-            params_buf_.keys[params_buf__i] = params_buf__key;
-            params_buf_.values[params_buf__i] = params_buf__value;
-        }
-        params_buf.value = params_buf_;
+        immersiveMode_buf.value = static_cast<Ark_ImmersiveMode>(valueDeserializer.readInt32());
     }
-    value.params = params_buf;
-    return value;
-}
-inline void NavigationMenuOptions_serializer::write(SerializerBase& buffer, Ark_NavigationMenuOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_moreButtonOptions = value.moreButtonOptions;
-    Ark_Int32 value_moreButtonOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_moreButtonOptions_type = runtimeType(value_moreButtonOptions);
-    valueSerializer.writeInt8(value_moreButtonOptions_type);
-    if ((value_moreButtonOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_moreButtonOptions_value = value_moreButtonOptions.value;
-        MoreButtonOptions_serializer::write(valueSerializer, value_moreButtonOptions_value);
+    value.immersiveMode = immersiveMode_buf;
+    const auto levelOrder_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LevelOrder levelOrder_buf = {};
+    levelOrder_buf.tag = levelOrder_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((levelOrder_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        levelOrder_buf.value = static_cast<Ark_LevelOrder>(LevelOrder_serializer::read(valueDeserializer));
     }
-}
-inline Ark_NavigationMenuOptions NavigationMenuOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_NavigationMenuOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto moreButtonOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_MoreButtonOptions moreButtonOptions_buf = {};
-    moreButtonOptions_buf.tag = moreButtonOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((moreButtonOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.levelOrder = levelOrder_buf;
+    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean focusable_buf = {};
+    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        moreButtonOptions_buf.value = MoreButtonOptions_serializer::read(valueDeserializer);
+        focusable_buf.value = valueDeserializer.readBoolean();
     }
-    value.moreButtonOptions = moreButtonOptions_buf;
+    value.focusable = focusable_buf;
     return value;
 }
-inline void NavigationToolbarOptions_serializer::write(SerializerBase& buffer, Ark_NavigationToolbarOptions value)
+inline void CustomPopupOptions_serializer::write(SerializerBase& buffer, Ark_CustomPopupOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value_builder = value.builder;
+    valueSerializer.writeCallbackResource(value_builder.resource);
+    valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder.call));
+    valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder.callSync));
+    const auto value_placement = value.placement;
+    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placement_type = runtimeType(value_placement);
+    valueSerializer.writeInt8(value_placement_type);
+    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placement_value = value_placement.value;
+        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
+    }
+    const auto value_popupColor = value.popupColor;
+    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_popupColor_type = runtimeType(value_popupColor);
+    valueSerializer.writeInt8(value_popupColor_type);
+    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_popupColor_value = value_popupColor.value;
+        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_popupColor_value_type = value_popupColor_value.selector;
+        if (value_popupColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_popupColor_value_0 = value_popupColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_popupColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
+            const auto value_popupColor_value_1 = value_popupColor_value.value1;
+            valueSerializer.writeString(value_popupColor_value_1);
         }
-        else if (value_backgroundColor_value_type == 2) {
+        else if (value_popupColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
+            const auto value_popupColor_value_2 = value_popupColor_value.value2;
+            Resource_serializer::write(valueSerializer, value_popupColor_value_2);
         }
-        else if (value_backgroundColor_value_type == 3) {
+        else if (value_popupColor_value_type == 3) {
             valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_popupColor_value_3 = value_popupColor_value.value3;
+            valueSerializer.writeNumber(value_popupColor_value_3);
         }
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
-    }
-    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
-    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
-    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
-    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
-        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
+    const auto value_enableArrow = value.enableArrow;
+    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableArrow_type = runtimeType(value_enableArrow);
+    valueSerializer.writeInt8(value_enableArrow_type);
+    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableArrow_value = value_enableArrow.value;
+        valueSerializer.writeBoolean(value_enableArrow_value);
     }
-    const auto value_backgroundEffect = value.backgroundEffect;
-    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
-    valueSerializer.writeInt8(value_backgroundEffect_type);
-    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundEffect_value = value_backgroundEffect.value;
-        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
+    const auto value_autoCancel = value.autoCancel;
+    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_autoCancel_type = runtimeType(value_autoCancel);
+    valueSerializer.writeInt8(value_autoCancel_type);
+    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_autoCancel_value = value_autoCancel.value;
+        valueSerializer.writeBoolean(value_autoCancel_value);
     }
-    const auto value_moreButtonOptions = value.moreButtonOptions;
-    Ark_Int32 value_moreButtonOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_moreButtonOptions_type = runtimeType(value_moreButtonOptions);
-    valueSerializer.writeInt8(value_moreButtonOptions_type);
-    if ((value_moreButtonOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_moreButtonOptions_value = value_moreButtonOptions.value;
-        MoreButtonOptions_serializer::write(valueSerializer, value_moreButtonOptions_value);
+    const auto value_onStateChange = value.onStateChange;
+    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onStateChange_type = runtimeType(value_onStateChange);
+    valueSerializer.writeInt8(value_onStateChange_type);
+    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onStateChange_value = value_onStateChange.value;
+        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
     }
-    const auto value_barStyle = value.barStyle;
-    Ark_Int32 value_barStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_barStyle_type = runtimeType(value_barStyle);
-    valueSerializer.writeInt8(value_barStyle_type);
-    if ((value_barStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_barStyle_value = value_barStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BarStyle>(value_barStyle_value));
+    const auto value_arrowOffset = value.arrowOffset;
+    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowOffset_type = runtimeType(value_arrowOffset);
+    valueSerializer.writeInt8(value_arrowOffset_type);
+    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowOffset_value = value_arrowOffset.value;
+        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowOffset_value_type = value_arrowOffset_value.selector;
+        if (value_arrowOffset_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
+            valueSerializer.writeString(value_arrowOffset_value_0);
+        }
+        else if (value_arrowOffset_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
+            valueSerializer.writeNumber(value_arrowOffset_value_1);
+        }
+        else if (value_arrowOffset_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
+        }
     }
-    const auto value_hideItemValue = value.hideItemValue;
-    Ark_Int32 value_hideItemValue_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hideItemValue_type = runtimeType(value_hideItemValue);
-    valueSerializer.writeInt8(value_hideItemValue_type);
-    if ((value_hideItemValue_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hideItemValue_value = value_hideItemValue.value;
-        valueSerializer.writeBoolean(value_hideItemValue_value);
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
     }
-}
-inline Ark_NavigationToolbarOptions NavigationToolbarOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_NavigationToolbarOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+    const auto value_mask = value.mask;
+    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
+    value_mask_type = runtimeType(value_mask);
+    valueSerializer.writeInt8(value_mask_type);
+    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_mask_value = value_mask.value;
+        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_mask_value_type = value_mask_value.selector;
+        if (value_mask_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_mask_value_0 = value_mask_value.value0;
+            valueSerializer.writeBoolean(value_mask_value_0);
         }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (value_mask_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_mask_value_1 = value_mask_value.value1;
+            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
         }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    const auto value_targetSpace = value.targetSpace;
+    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_targetSpace_type = runtimeType(value_targetSpace);
+    valueSerializer.writeInt8(value_targetSpace_type);
+    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_targetSpace_value = value_targetSpace.value;
+        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_targetSpace_value_type = value_targetSpace_value.selector;
+        if (value_targetSpace_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
+            valueSerializer.writeString(value_targetSpace_value_0);
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (value_targetSpace_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
+            valueSerializer.writeNumber(value_targetSpace_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        else if (value_targetSpace_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
+            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
-    }
-    value.backgroundColor = backgroundColor_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
-    }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
-    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
-    }
-    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
-    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
-    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
-    }
-    value.backgroundEffect = backgroundEffect_buf;
-    const auto moreButtonOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_MoreButtonOptions moreButtonOptions_buf = {};
-    moreButtonOptions_buf.tag = moreButtonOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((moreButtonOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        moreButtonOptions_buf.value = MoreButtonOptions_serializer::read(valueDeserializer);
-    }
-    value.moreButtonOptions = moreButtonOptions_buf;
-    const auto barStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BarStyle barStyle_buf = {};
-    barStyle_buf.tag = barStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((barStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        barStyle_buf.value = static_cast<Ark_BarStyle>(valueDeserializer.readInt32());
     }
-    value.barStyle = barStyle_buf;
-    const auto hideItemValue_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean hideItemValue_buf = {};
-    hideItemValue_buf.tag = hideItemValue_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hideItemValue_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        hideItemValue_buf.value = valueDeserializer.readBoolean();
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Position_serializer::write(valueSerializer, value_offset_value);
     }
-    value.hideItemValue = hideItemValue_buf;
-    return value;
-}
-inline void OutlineOptions_serializer::write(SerializerBase& buffer, Ark_OutlineOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
     const auto value_width = value.width;
     Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
     value_width_type = runtimeType(value_width);
@@ -106286,73 +108450,73 @@ inline void OutlineOptions_serializer::write(SerializerBase& buffer, Ark_Outline
         if (value_width_value_type == 0) {
             valueSerializer.writeInt8(0);
             const auto value_width_value_0 = value_width_value.value0;
-            EdgeOutlineWidths_serializer::write(valueSerializer, value_width_value_0);
+            valueSerializer.writeString(value_width_value_0);
         }
-        else if ((value_width_value_type == 1) || (value_width_value_type == 1) || (value_width_value_type == 1)) {
+        else if (value_width_value_type == 1) {
             valueSerializer.writeInt8(1);
             const auto value_width_value_1 = value_width_value.value1;
-            Ark_Int32 value_width_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_width_value_1_type = value_width_value_1.selector;
-            if (value_width_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_width_value_1_0 = value_width_value_1.value0;
-                valueSerializer.writeString(value_width_value_1_0);
-            }
-            else if (value_width_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_width_value_1_1 = value_width_value_1.value1;
-                valueSerializer.writeNumber(value_width_value_1_1);
-            }
-            else if (value_width_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_width_value_1_2 = value_width_value_1.value2;
-                Resource_serializer::write(valueSerializer, value_width_value_1_2);
-            }
+            valueSerializer.writeNumber(value_width_value_1);
+        }
+        else if (value_width_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_width_value_2 = value_width_value.value2;
+            Resource_serializer::write(valueSerializer, value_width_value_2);
         }
     }
-    const auto value_color = value.color;
-    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
-    value_color_type = runtimeType(value_color);
-    valueSerializer.writeInt8(value_color_type);
-    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_color_value = value_color.value;
-        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_color_value_type = value_color_value.selector;
-        if (value_color_value_type == 0) {
+    const auto value_arrowPointPosition = value.arrowPointPosition;
+    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
+    valueSerializer.writeInt8(value_arrowPointPosition_type);
+    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
+        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
+    }
+    const auto value_arrowWidth = value.arrowWidth;
+    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowWidth_type = runtimeType(value_arrowWidth);
+    valueSerializer.writeInt8(value_arrowWidth_type);
+    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowWidth_value = value_arrowWidth.value;
+        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowWidth_value_type = value_arrowWidth_value.selector;
+        if (value_arrowWidth_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_color_value_0 = value_color_value.value0;
-            EdgeColors_serializer::write(valueSerializer, value_color_value_0);
+            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
+            valueSerializer.writeString(value_arrowWidth_value_0);
         }
-        else if ((value_color_value_type == 1) || (value_color_value_type == 1) || (value_color_value_type == 1) || (value_color_value_type == 1)) {
+        else if (value_arrowWidth_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_color_value_1 = value_color_value.value1;
-            Ark_Int32 value_color_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_color_value_1_type = value_color_value_1.selector;
-            if (value_color_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_color_value_1_0 = value_color_value_1.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_1_0));
-            }
-            else if (value_color_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_color_value_1_1 = value_color_value_1.value1;
-                valueSerializer.writeNumber(value_color_value_1_1);
-            }
-            else if (value_color_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_color_value_1_2 = value_color_value_1.value2;
-                valueSerializer.writeString(value_color_value_1_2);
-            }
-            else if (value_color_value_1_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_color_value_1_3 = value_color_value_1.value3;
-                Resource_serializer::write(valueSerializer, value_color_value_1_3);
-            }
+            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
+            valueSerializer.writeNumber(value_arrowWidth_value_1);
         }
-        else if (value_color_value_type == 2) {
+        else if (value_arrowWidth_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_color_value_2 = value_color_value.value2;
-            LocalizedEdgeColors_serializer::write(valueSerializer, value_color_value_2);
+            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
+        }
+    }
+    const auto value_arrowHeight = value.arrowHeight;
+    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowHeight_type = runtimeType(value_arrowHeight);
+    valueSerializer.writeInt8(value_arrowHeight_type);
+    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowHeight_value = value_arrowHeight.value;
+        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowHeight_value_type = value_arrowHeight_value.selector;
+        if (value_arrowHeight_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
+            valueSerializer.writeString(value_arrowHeight_value_0);
+        }
+        else if (value_arrowHeight_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
+            valueSerializer.writeNumber(value_arrowHeight_value_1);
+        }
+        else if (value_arrowHeight_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
         }
     }
     const auto value_radius = value.radius;
@@ -106366,1108 +108530,1111 @@ inline void OutlineOptions_serializer::write(SerializerBase& buffer, Ark_Outline
         if (value_radius_value_type == 0) {
             valueSerializer.writeInt8(0);
             const auto value_radius_value_0 = value_radius_value.value0;
-            OutlineRadiuses_serializer::write(valueSerializer, value_radius_value_0);
+            valueSerializer.writeString(value_radius_value_0);
         }
-        else if ((value_radius_value_type == 1) || (value_radius_value_type == 1) || (value_radius_value_type == 1)) {
+        else if (value_radius_value_type == 1) {
             valueSerializer.writeInt8(1);
             const auto value_radius_value_1 = value_radius_value.value1;
-            Ark_Int32 value_radius_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_radius_value_1_type = value_radius_value_1.selector;
-            if (value_radius_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_radius_value_1_0 = value_radius_value_1.value0;
-                valueSerializer.writeString(value_radius_value_1_0);
-            }
-            else if (value_radius_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_radius_value_1_1 = value_radius_value_1.value1;
-                valueSerializer.writeNumber(value_radius_value_1_1);
-            }
-            else if (value_radius_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_radius_value_1_2 = value_radius_value_1.value2;
-                Resource_serializer::write(valueSerializer, value_radius_value_1_2);
-            }
+            valueSerializer.writeNumber(value_radius_value_1);
+        }
+        else if (value_radius_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_radius_value_2 = value_radius_value.value2;
+            Resource_serializer::write(valueSerializer, value_radius_value_2);
         }
     }
-    const auto value_style = value.style;
-    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
-    value_style_type = runtimeType(value_style);
-    valueSerializer.writeInt8(value_style_type);
-    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_style_value = value_style.value;
-        Ark_Int32 value_style_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_style_value_type = value_style_value.selector;
-        if (value_style_value_type == 0) {
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_style_value_0 = value_style_value.value0;
-            EdgeOutlineStyles_serializer::write(valueSerializer, value_style_value_0);
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
         }
-        else if (value_style_value_type == 1) {
+        else if (value_shadow_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_style_value_1 = value_style_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_OutlineStyle>(value_style_value_1));
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+        }
+    }
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
+    }
+    const auto value_focusable = value.focusable;
+    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusable_type = runtimeType(value_focusable);
+    valueSerializer.writeInt8(value_focusable_type);
+    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusable_value = value_focusable.value;
+        valueSerializer.writeBoolean(value_focusable_value);
+    }
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    }
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
+        if (value_onWillDismiss_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
+            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
+        }
+        else if (value_onWillDismiss_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
+            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
         }
     }
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHoverMode_value = value_enableHoverMode.value;
+        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    }
+    const auto value_followTransformOfTarget = value.followTransformOfTarget;
+    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
+    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
+    valueSerializer.writeInt8(value_followTransformOfTarget_type);
+    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
+        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
+    }
+    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
+    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
+    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
+    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
+    }
 }
-inline Ark_OutlineOptions OutlineOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_CustomPopupOptions CustomPopupOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_OutlineOptions value = {};
+    Ark_CustomPopupOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
+    value.builder = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Placement placement_buf = {};
+    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
+    }
+    value.placement = placement_buf;
+    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Color_String_Resource_Number popupColor_buf = {};
+    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Color_String_Resource_Number popupColor_buf_ = {};
+        popupColor_buf_.selector = popupColor_buf__selector;
+        if (popupColor_buf__selector == 0) {
+            popupColor_buf_.selector = 0;
+            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (popupColor_buf__selector == 1) {
+            popupColor_buf_.selector = 1;
+            popupColor_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (popupColor_buf__selector == 2) {
+            popupColor_buf_.selector = 2;
+            popupColor_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else if (popupColor_buf__selector == 3) {
+            popupColor_buf_.selector = 3;
+            popupColor_buf_.value3 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
+        }
+        popupColor_buf.value = static_cast<Ark_Union_Color_String_Resource_Number>(popupColor_buf_);
+    }
+    value.popupColor = popupColor_buf;
+    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableArrow_buf = {};
+    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableArrow_buf.value = valueDeserializer.readBoolean();
+    }
+    value.enableArrow = enableArrow_buf;
+    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean autoCancel_buf = {};
+    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        autoCancel_buf.value = valueDeserializer.readBoolean();
+    }
+    value.autoCancel = autoCancel_buf;
+    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupStateChangeCallback onStateChange_buf = {};
+    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
+    }
+    value.onStateChange = onStateChange_buf;
+    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length arrowOffset_buf = {};
+    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
+        Ark_Length arrowOffset_buf_ = {};
+        arrowOffset_buf_.selector = arrowOffset_buf__selector;
+        if (arrowOffset_buf__selector == 0) {
+            arrowOffset_buf_.selector = 0;
+            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowOffset_buf__selector == 1) {
+            arrowOffset_buf_.selector = 1;
+            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowOffset_buf__selector == 2) {
+            arrowOffset_buf_.selector = 2;
+            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
+        }
+        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
+    }
+    value.arrowOffset = arrowOffset_buf;
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+    }
+    value.showInSubWindow = showInSubWindow_buf;
+    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_PopupMaskType mask_buf = {};
+    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
+        mask_buf_.selector = mask_buf__selector;
+        if (mask_buf__selector == 0) {
+            mask_buf_.selector = 0;
+            mask_buf_.value0 = valueDeserializer.readBoolean();
+        }
+        else if (mask_buf__selector == 1) {
+            mask_buf_.selector = 1;
+            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
+        }
+        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
+    }
+    value.mask = mask_buf;
+    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length targetSpace_buf = {};
+    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
+        Ark_Length targetSpace_buf_ = {};
+        targetSpace_buf_.selector = targetSpace_buf__selector;
+        if (targetSpace_buf__selector == 0) {
+            targetSpace_buf_.selector = 0;
+            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (targetSpace_buf__selector == 1) {
+            targetSpace_buf_.selector = 1;
+            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (targetSpace_buf__selector == 2) {
+            targetSpace_buf_.selector = 2;
+            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
+        }
+        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
+    }
+    value.targetSpace = targetSpace_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offset_buf.value = Position_serializer::read(valueDeserializer);
+    }
+    value.offset = offset_buf;
     const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_EdgeOutlineWidths_Dimension width_buf = {};
+    Opt_Dimension width_buf = {};
     width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
         const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_EdgeOutlineWidths_Dimension width_buf_ = {};
+        Ark_Dimension width_buf_ = {};
         width_buf_.selector = width_buf__selector;
         if (width_buf__selector == 0) {
             width_buf_.selector = 0;
-            width_buf_.value0 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
         else if (width_buf__selector == 1) {
             width_buf_.selector = 1;
-            const Ark_Int8 width_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension width_buf__u = {};
-            width_buf__u.selector = width_buf__u_selector;
-            if (width_buf__u_selector == 0) {
-                width_buf__u.selector = 0;
-                width_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (width_buf__u_selector == 1) {
-                width_buf__u.selector = 1;
-                width_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (width_buf__u_selector == 2) {
-                width_buf__u.selector = 2;
-                width_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for width_buf__u has to be chosen through deserialisation.");
-            }
-            width_buf_.value1 = static_cast<Ark_Dimension>(width_buf__u);
+            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (width_buf__selector == 2) {
+            width_buf_.selector = 2;
+            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
             INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
         }
-        width_buf.value = static_cast<Ark_Union_EdgeOutlineWidths_Dimension>(width_buf_);
+        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
     }
     value.width = width_buf;
-    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_EdgeColors_ResourceColor_LocalizedEdgeColors color_buf = {};
-    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ArrowPointPosition arrowPointPosition_buf = {};
+    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_EdgeColors_ResourceColor_LocalizedEdgeColors color_buf_ = {};
-        color_buf_.selector = color_buf__selector;
-        if (color_buf__selector == 0) {
-            color_buf_.selector = 0;
-            color_buf_.value0 = EdgeColors_serializer::read(valueDeserializer);
+        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
+    }
+    value.arrowPointPosition = arrowPointPosition_buf;
+    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowWidth_buf = {};
+    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowWidth_buf_ = {};
+        arrowWidth_buf_.selector = arrowWidth_buf__selector;
+        if (arrowWidth_buf__selector == 0) {
+            arrowWidth_buf_.selector = 0;
+            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (color_buf__selector == 1) {
-            color_buf_.selector = 1;
-            const Ark_Int8 color_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor color_buf__u = {};
-            color_buf__u.selector = color_buf__u_selector;
-            if (color_buf__u_selector == 0) {
-                color_buf__u.selector = 0;
-                color_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-            }
-            else if (color_buf__u_selector == 1) {
-                color_buf__u.selector = 1;
-                color_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (color_buf__u_selector == 2) {
-                color_buf__u.selector = 2;
-                color_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (color_buf__u_selector == 3) {
-                color_buf__u.selector = 3;
-                color_buf__u.value3 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for color_buf__u has to be chosen through deserialisation.");
-            }
-            color_buf_.value1 = static_cast<Ark_ResourceColor>(color_buf__u);
+        else if (arrowWidth_buf__selector == 1) {
+            arrowWidth_buf_.selector = 1;
+            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (color_buf__selector == 2) {
-            color_buf_.selector = 2;
-            color_buf_.value2 = LocalizedEdgeColors_serializer::read(valueDeserializer);
+        else if (arrowWidth_buf__selector == 2) {
+            arrowWidth_buf_.selector = 2;
+            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
         }
-        color_buf.value = static_cast<Ark_Union_EdgeColors_ResourceColor_LocalizedEdgeColors>(color_buf_);
+        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
     }
-    value.color = color_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_OutlineRadiuses_Dimension radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowWidth = arrowWidth_buf;
+    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowHeight_buf = {};
+    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_OutlineRadiuses_Dimension radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            radius_buf_.value0 = OutlineRadiuses_serializer::read(valueDeserializer);
+        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowHeight_buf_ = {};
+        arrowHeight_buf_.selector = arrowHeight_buf__selector;
+        if (arrowHeight_buf__selector == 0) {
+            arrowHeight_buf_.selector = 0;
+            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            const Ark_Int8 radius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension radius_buf__u = {};
-            radius_buf__u.selector = radius_buf__u_selector;
-            if (radius_buf__u_selector == 0) {
-                radius_buf__u.selector = 0;
-                radius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (radius_buf__u_selector == 1) {
-                radius_buf__u.selector = 1;
-                radius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (radius_buf__u_selector == 2) {
-                radius_buf__u.selector = 2;
-                radius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for radius_buf__u has to be chosen through deserialisation.");
-            }
-            radius_buf_.value1 = static_cast<Ark_Dimension>(radius_buf__u);
+        else if (arrowHeight_buf__selector == 1) {
+            arrowHeight_buf_.selector = 1;
+            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowHeight_buf__selector == 2) {
+            arrowHeight_buf_.selector = 2;
+            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
         }
-        radius_buf.value = static_cast<Ark_Union_OutlineRadiuses_Dimension>(radius_buf_);
+        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
     }
-    value.radius = radius_buf;
-    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_EdgeOutlineStyles_OutlineStyle style_buf = {};
-    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowHeight = arrowHeight_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 style_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_EdgeOutlineStyles_OutlineStyle style_buf_ = {};
-        style_buf_.selector = style_buf__selector;
-        if (style_buf__selector == 0) {
-            style_buf_.selector = 0;
-            style_buf_.value0 = EdgeOutlineStyles_serializer::read(valueDeserializer);
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (style_buf__selector == 1) {
-            style_buf_.selector = 1;
-            style_buf_.value1 = static_cast<Ark_OutlineStyle>(valueDeserializer.readInt32());
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (radius_buf__selector == 2) {
+            radius_buf_.selector = 2;
+            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for style_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
         }
-        style_buf.value = static_cast<Ark_Union_EdgeOutlineStyles_OutlineStyle>(style_buf_);
-    }
-    value.style = style_buf;
-    return value;
-}
-inline void PanGestureEvent_serializer::write(SerializerBase& buffer, Ark_PanGestureEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_PanGestureEvent PanGestureEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_PanGestureEvent>(ptr);
-}
-inline void ParagraphStyle_serializer::write(SerializerBase& buffer, Ark_ParagraphStyle value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_ParagraphStyle ParagraphStyle_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_ParagraphStyle>(ptr);
-}
-inline void ParagraphStyleInterface_serializer::write(SerializerBase& buffer, Ark_ParagraphStyleInterface value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_textAlign = value.textAlign;
-    Ark_Int32 value_textAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textAlign_type = runtimeType(value_textAlign);
-    valueSerializer.writeInt8(value_textAlign_type);
-    if ((value_textAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textAlign_value = value_textAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextAlign>(value_textAlign_value));
-    }
-    const auto value_textIndent = value.textIndent;
-    Ark_Int32 value_textIndent_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textIndent_type = runtimeType(value_textIndent);
-    valueSerializer.writeInt8(value_textIndent_type);
-    if ((value_textIndent_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textIndent_value = value_textIndent.value;
-        LengthMetrics_serializer::write(valueSerializer, value_textIndent_value);
-    }
-    const auto value_maxLines = value.maxLines;
-    Ark_Int32 value_maxLines_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maxLines_type = runtimeType(value_maxLines);
-    valueSerializer.writeInt8(value_maxLines_type);
-    if ((value_maxLines_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maxLines_value = value_maxLines.value;
-        valueSerializer.writeNumber(value_maxLines_value);
-    }
-    const auto value_overflow = value.overflow;
-    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_overflow_type = runtimeType(value_overflow);
-    valueSerializer.writeInt8(value_overflow_type);
-    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_overflow_value = value_overflow.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
-    }
-    const auto value_wordBreak = value.wordBreak;
-    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
-    value_wordBreak_type = runtimeType(value_wordBreak);
-    valueSerializer.writeInt8(value_wordBreak_type);
-    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_wordBreak_value = value_wordBreak.value;
-        valueSerializer.writeInt32(static_cast<Ark_WordBreak>(value_wordBreak_value));
+        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
     }
-    const auto value_leadingMargin = value.leadingMargin;
-    Ark_Int32 value_leadingMargin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_leadingMargin_type = runtimeType(value_leadingMargin);
-    valueSerializer.writeInt8(value_leadingMargin_type);
-    if ((value_leadingMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_leadingMargin_value = value_leadingMargin.value;
-        Ark_Int32 value_leadingMargin_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_leadingMargin_value_type = value_leadingMargin_value.selector;
-        if (value_leadingMargin_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_leadingMargin_value_0 = value_leadingMargin_value.value0;
-            LengthMetrics_serializer::write(valueSerializer, value_leadingMargin_value_0);
+    value.radius = radius_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
         }
-        else if (value_leadingMargin_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_leadingMargin_value_1 = value_leadingMargin_value.value1;
-            LeadingMarginPlaceholder_serializer::write(valueSerializer, value_leadingMargin_value_1);
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
         }
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+        }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
-    const auto value_paragraphSpacing = value.paragraphSpacing;
-    Ark_Int32 value_paragraphSpacing_type = INTEROP_RUNTIME_UNDEFINED;
-    value_paragraphSpacing_type = runtimeType(value_paragraphSpacing);
-    valueSerializer.writeInt8(value_paragraphSpacing_type);
-    if ((value_paragraphSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_paragraphSpacing_value = value_paragraphSpacing.value;
-        LengthMetrics_serializer::write(valueSerializer, value_paragraphSpacing_value);
-    }
-}
-inline Ark_ParagraphStyleInterface ParagraphStyleInterface_serializer::read(DeserializerBase& buffer)
-{
-    Ark_ParagraphStyleInterface value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto textAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextAlign textAlign_buf = {};
-    textAlign_buf.tag = textAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textAlign_buf.value = static_cast<Ark_TextAlign>(valueDeserializer.readInt32());
-    }
-    value.textAlign = textAlign_buf;
-    const auto textIndent_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LengthMetrics textIndent_buf = {};
-    textIndent_buf.tag = textIndent_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textIndent_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textIndent_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
-    }
-    value.textIndent = textIndent_buf;
-    const auto maxLines_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number maxLines_buf = {};
-    maxLines_buf.tag = maxLines_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maxLines_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.shadow = shadow_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        maxLines_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    value.maxLines = maxLines_buf;
-    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextOverflow overflow_buf = {};
-    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean focusable_buf = {};
+    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
+        focusable_buf.value = valueDeserializer.readBoolean();
     }
-    value.overflow = overflow_buf;
-    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_WordBreak wordBreak_buf = {};
-    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.focusable = focusable_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        wordBreak_buf.value = static_cast<Ark_WordBreak>(valueDeserializer.readInt32());
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
     }
-    value.wordBreak = wordBreak_buf;
-    const auto leadingMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_LengthMetrics_LeadingMarginPlaceholder leadingMargin_buf = {};
-    leadingMargin_buf.tag = leadingMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((leadingMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.transition = transition_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 leadingMargin_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_LengthMetrics_LeadingMarginPlaceholder leadingMargin_buf_ = {};
-        leadingMargin_buf_.selector = leadingMargin_buf__selector;
-        if (leadingMargin_buf__selector == 0) {
-            leadingMargin_buf_.selector = 0;
-            leadingMargin_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
+        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
+        if (onWillDismiss_buf__selector == 0) {
+            onWillDismiss_buf_.selector = 0;
+            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
         }
-        else if (leadingMargin_buf__selector == 1) {
-            leadingMargin_buf_.selector = 1;
-            leadingMargin_buf_.value1 = LeadingMarginPlaceholder_serializer::read(valueDeserializer);
+        else if (onWillDismiss_buf__selector == 1) {
+            onWillDismiss_buf_.selector = 1;
+            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
         }
         else {
-            INTEROP_FATAL("One of the branches for leadingMargin_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
         }
-        leadingMargin_buf.value = static_cast<Ark_Union_LengthMetrics_LeadingMarginPlaceholder>(leadingMargin_buf_);
+        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
     }
-    value.leadingMargin = leadingMargin_buf;
-    const auto paragraphSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LengthMetrics paragraphSpacing_buf = {};
-    paragraphSpacing_buf.tag = paragraphSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((paragraphSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillDismiss = onWillDismiss_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        paragraphSpacing_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
-    value.paragraphSpacing = paragraphSpacing_buf;
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean followTransformOfTarget_buf = {};
+    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
+    }
+    value.followTransformOfTarget = followTransformOfTarget_buf;
+    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
+    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
+    }
+    value.keyboardAvoidMode = keyboardAvoidMode_buf;
     return value;
 }
-inline void PickerDialogButtonStyle_serializer::write(SerializerBase& buffer, Ark_PickerDialogButtonStyle value)
+inline void DigitIndicator_serializer::write(SerializerBase& buffer, Ark_DigitIndicator value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_type = value.type;
-    Ark_Int32 value_type_type = INTEROP_RUNTIME_UNDEFINED;
-    value_type_type = runtimeType(value_type);
-    valueSerializer.writeInt8(value_type_type);
-    if ((value_type_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_type_value = value_type.value;
-        valueSerializer.writeInt32(static_cast<Ark_ButtonType>(value_type_value));
-    }
-    const auto value_style = value.style;
-    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
-    value_style_type = runtimeType(value_style);
-    valueSerializer.writeInt8(value_style_type);
-    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_style_value = value_style.value;
-        valueSerializer.writeInt32(static_cast<Ark_ButtonStyleMode>(value_style_value));
-    }
-    const auto value_role = value.role;
-    Ark_Int32 value_role_type = INTEROP_RUNTIME_UNDEFINED;
-    value_role_type = runtimeType(value_role);
-    valueSerializer.writeInt8(value_role_type);
-    if ((value_role_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_role_value = value_role.value;
-        valueSerializer.writeInt32(static_cast<Ark_ButtonRole>(value_role_value));
-    }
-    const auto value_fontSize = value.fontSize;
-    Ark_Int32 value_fontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontSize_type = runtimeType(value_fontSize);
-    valueSerializer.writeInt8(value_fontSize_type);
-    if ((value_fontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontSize_value = value_fontSize.value;
-        Ark_Int32 value_fontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontSize_value_type = value_fontSize_value.selector;
-        if (value_fontSize_value_type == 0) {
+    const auto value__left = value._left;
+    Ark_Int32 value__left_type = INTEROP_RUNTIME_UNDEFINED;
+    value__left_type = runtimeType(value__left);
+    valueSerializer.writeInt8(value__left_type);
+    if ((value__left_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__left_value = value__left.value;
+        Ark_Int32 value__left_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__left_value_type = value__left_value.selector;
+        if (value__left_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontSize_value_0 = value_fontSize_value.value0;
-            valueSerializer.writeString(value_fontSize_value_0);
+            const auto value__left_value_0 = value__left_value.value0;
+            valueSerializer.writeString(value__left_value_0);
         }
-        else if (value_fontSize_value_type == 1) {
+        else if (value__left_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontSize_value_1 = value_fontSize_value.value1;
-            valueSerializer.writeNumber(value_fontSize_value_1);
+            const auto value__left_value_1 = value__left_value.value1;
+            valueSerializer.writeNumber(value__left_value_1);
         }
-        else if (value_fontSize_value_type == 2) {
+        else if (value__left_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_fontSize_value_2 = value_fontSize_value.value2;
-            Resource_serializer::write(valueSerializer, value_fontSize_value_2);
+            const auto value__left_value_2 = value__left_value.value2;
+            Resource_serializer::write(valueSerializer, value__left_value_2);
         }
     }
-    const auto value_fontColor = value.fontColor;
-    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontColor_type = runtimeType(value_fontColor);
-    valueSerializer.writeInt8(value_fontColor_type);
-    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontColor_value = value_fontColor.value;
-        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontColor_value_type = value_fontColor_value.selector;
-        if (value_fontColor_value_type == 0) {
+    const auto value__top = value._top;
+    Ark_Int32 value__top_type = INTEROP_RUNTIME_UNDEFINED;
+    value__top_type = runtimeType(value__top);
+    valueSerializer.writeInt8(value__top_type);
+    if ((value__top_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__top_value = value__top.value;
+        Ark_Int32 value__top_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__top_value_type = value__top_value.selector;
+        if (value__top_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontColor_value_0 = value_fontColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
+            const auto value__top_value_0 = value__top_value.value0;
+            valueSerializer.writeString(value__top_value_0);
         }
-        else if (value_fontColor_value_type == 1) {
+        else if (value__top_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontColor_value_1 = value_fontColor_value.value1;
-            valueSerializer.writeNumber(value_fontColor_value_1);
+            const auto value__top_value_1 = value__top_value.value1;
+            valueSerializer.writeNumber(value__top_value_1);
         }
-        else if (value_fontColor_value_type == 2) {
+        else if (value__top_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_fontColor_value_2 = value_fontColor_value.value2;
-            valueSerializer.writeString(value_fontColor_value_2);
-        }
-        else if (value_fontColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_fontColor_value_3 = value_fontColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
+            const auto value__top_value_2 = value__top_value.value2;
+            Resource_serializer::write(valueSerializer, value__top_value_2);
         }
     }
-    const auto value_fontWeight = value.fontWeight;
-    Ark_Int32 value_fontWeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontWeight_type = runtimeType(value_fontWeight);
-    valueSerializer.writeInt8(value_fontWeight_type);
-    if ((value_fontWeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontWeight_value = value_fontWeight.value;
-        Ark_Int32 value_fontWeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontWeight_value_type = value_fontWeight_value.selector;
-        if (value_fontWeight_value_type == 0) {
+    const auto value__right = value._right;
+    Ark_Int32 value__right_type = INTEROP_RUNTIME_UNDEFINED;
+    value__right_type = runtimeType(value__right);
+    valueSerializer.writeInt8(value__right_type);
+    if ((value__right_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__right_value = value__right.value;
+        Ark_Int32 value__right_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__right_value_type = value__right_value.selector;
+        if (value__right_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontWeight_value_0 = value_fontWeight_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_FontWeight>(value_fontWeight_value_0));
+            const auto value__right_value_0 = value__right_value.value0;
+            valueSerializer.writeString(value__right_value_0);
         }
-        else if (value_fontWeight_value_type == 1) {
+        else if (value__right_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontWeight_value_1 = value_fontWeight_value.value1;
-            valueSerializer.writeNumber(value_fontWeight_value_1);
+            const auto value__right_value_1 = value__right_value.value1;
+            valueSerializer.writeNumber(value__right_value_1);
         }
-        else if (value_fontWeight_value_type == 2) {
+        else if (value__right_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_fontWeight_value_2 = value_fontWeight_value.value2;
-            valueSerializer.writeString(value_fontWeight_value_2);
+            const auto value__right_value_2 = value__right_value.value2;
+            Resource_serializer::write(valueSerializer, value__right_value_2);
         }
     }
-    const auto value_fontStyle = value.fontStyle;
-    Ark_Int32 value_fontStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontStyle_type = runtimeType(value_fontStyle);
-    valueSerializer.writeInt8(value_fontStyle_type);
-    if ((value_fontStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontStyle_value = value_fontStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle_value));
-    }
-    const auto value_fontFamily = value.fontFamily;
-    Ark_Int32 value_fontFamily_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontFamily_type = runtimeType(value_fontFamily);
-    valueSerializer.writeInt8(value_fontFamily_type);
-    if ((value_fontFamily_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontFamily_value = value_fontFamily.value;
-        Ark_Int32 value_fontFamily_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontFamily_value_type = value_fontFamily_value.selector;
-        if (value_fontFamily_value_type == 0) {
+    const auto value__bottom = value._bottom;
+    Ark_Int32 value__bottom_type = INTEROP_RUNTIME_UNDEFINED;
+    value__bottom_type = runtimeType(value__bottom);
+    valueSerializer.writeInt8(value__bottom_type);
+    if ((value__bottom_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__bottom_value = value__bottom.value;
+        Ark_Int32 value__bottom_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__bottom_value_type = value__bottom_value.selector;
+        if (value__bottom_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontFamily_value_0 = value_fontFamily_value.value0;
-            Resource_serializer::write(valueSerializer, value_fontFamily_value_0);
+            const auto value__bottom_value_0 = value__bottom_value.value0;
+            valueSerializer.writeString(value__bottom_value_0);
         }
-        else if (value_fontFamily_value_type == 1) {
+        else if (value__bottom_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontFamily_value_1 = value_fontFamily_value.value1;
-            valueSerializer.writeString(value_fontFamily_value_1);
+            const auto value__bottom_value_1 = value__bottom_value.value1;
+            valueSerializer.writeNumber(value__bottom_value_1);
+        }
+        else if (value__bottom_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value__bottom_value_2 = value__bottom_value.value2;
+            Resource_serializer::write(valueSerializer, value__bottom_value_2);
         }
     }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value__start = value._start;
+    Ark_Int32 value__start_type = INTEROP_RUNTIME_UNDEFINED;
+    value__start_type = runtimeType(value__start);
+    valueSerializer.writeInt8(value__start_type);
+    if ((value__start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__start_value = value__start.value;
+        LengthMetrics_serializer::write(valueSerializer, value__start_value);
+    }
+    const auto value__end = value._end;
+    Ark_Int32 value__end_type = INTEROP_RUNTIME_UNDEFINED;
+    value__end_type = runtimeType(value__end);
+    valueSerializer.writeInt8(value__end_type);
+    if ((value__end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__end_value = value__end.value;
+        LengthMetrics_serializer::write(valueSerializer, value__end_value);
+    }
+    const auto value__fontColor = value._fontColor;
+    Ark_Int32 value__fontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value__fontColor_type = runtimeType(value__fontColor);
+    valueSerializer.writeInt8(value__fontColor_type);
+    if ((value__fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__fontColor_value = value__fontColor.value;
+        Ark_Int32 value__fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__fontColor_value_type = value__fontColor_value.selector;
+        if (value__fontColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value__fontColor_value_0 = value__fontColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value__fontColor_value_0));
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value__fontColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
+            const auto value__fontColor_value_1 = value__fontColor_value.value1;
+            valueSerializer.writeNumber(value__fontColor_value_1);
         }
-        else if (value_backgroundColor_value_type == 2) {
+        else if (value__fontColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
+            const auto value__fontColor_value_2 = value__fontColor_value.value2;
+            valueSerializer.writeString(value__fontColor_value_2);
         }
-        else if (value_backgroundColor_value_type == 3) {
+        else if (value__fontColor_value_type == 3) {
             valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value__fontColor_value_3 = value__fontColor_value.value3;
+            Resource_serializer::write(valueSerializer, value__fontColor_value_3);
         }
     }
-    const auto value_borderRadius = value.borderRadius;
-    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderRadius_type = runtimeType(value_borderRadius);
-    valueSerializer.writeInt8(value_borderRadius_type);
-    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderRadius_value = value_borderRadius.value;
-        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderRadius_value_type = value_borderRadius_value.selector;
-        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
+    const auto value__selectedFontColor = value._selectedFontColor;
+    Ark_Int32 value__selectedFontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value__selectedFontColor_type = runtimeType(value__selectedFontColor);
+    valueSerializer.writeInt8(value__selectedFontColor_type);
+    if ((value__selectedFontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__selectedFontColor_value = value__selectedFontColor.value;
+        Ark_Int32 value__selectedFontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__selectedFontColor_value_type = value__selectedFontColor_value.selector;
+        if (value__selectedFontColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
-            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
-            if (value_borderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
-                valueSerializer.writeString(value_borderRadius_value_0_0);
-            }
-            else if (value_borderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_borderRadius_value_0_1);
-            }
-            else if (value_borderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
-            }
+            const auto value__selectedFontColor_value_0 = value__selectedFontColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value__selectedFontColor_value_0));
         }
-        else if (value_borderRadius_value_type == 1) {
+        else if (value__selectedFontColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
+            const auto value__selectedFontColor_value_1 = value__selectedFontColor_value.value1;
+            valueSerializer.writeNumber(value__selectedFontColor_value_1);
+        }
+        else if (value__selectedFontColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value__selectedFontColor_value_2 = value__selectedFontColor_value.value2;
+            valueSerializer.writeString(value__selectedFontColor_value_2);
+        }
+        else if (value__selectedFontColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value__selectedFontColor_value_3 = value__selectedFontColor_value.value3;
+            Resource_serializer::write(valueSerializer, value__selectedFontColor_value_3);
         }
     }
-    const auto value_primary = value.primary;
-    Ark_Int32 value_primary_type = INTEROP_RUNTIME_UNDEFINED;
-    value_primary_type = runtimeType(value_primary);
-    valueSerializer.writeInt8(value_primary_type);
-    if ((value_primary_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_primary_value = value_primary.value;
-        valueSerializer.writeBoolean(value_primary_value);
+    const auto value__digitFont = value._digitFont;
+    Ark_Int32 value__digitFont_type = INTEROP_RUNTIME_UNDEFINED;
+    value__digitFont_type = runtimeType(value__digitFont);
+    valueSerializer.writeInt8(value__digitFont_type);
+    if ((value__digitFont_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__digitFont_value = value__digitFont.value;
+        Font_serializer::write(valueSerializer, value__digitFont_value);
+    }
+    const auto value__selectedDigitFont = value._selectedDigitFont;
+    Ark_Int32 value__selectedDigitFont_type = INTEROP_RUNTIME_UNDEFINED;
+    value__selectedDigitFont_type = runtimeType(value__selectedDigitFont);
+    valueSerializer.writeInt8(value__selectedDigitFont_type);
+    if ((value__selectedDigitFont_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__selectedDigitFont_value = value__selectedDigitFont.value;
+        Font_serializer::write(valueSerializer, value__selectedDigitFont_value);
     }
 }
-inline Ark_PickerDialogButtonStyle PickerDialogButtonStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_DigitIndicator DigitIndicator_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PickerDialogButtonStyle value = {};
+    Ark_DigitIndicator value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto type_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ButtonType type_buf = {};
-    type_buf.tag = type_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((type_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        type_buf.value = static_cast<Ark_ButtonType>(valueDeserializer.readInt32());
-    }
-    value.type = type_buf;
-    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ButtonStyleMode style_buf = {};
-    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        style_buf.value = static_cast<Ark_ButtonStyleMode>(valueDeserializer.readInt32());
-    }
-    value.style = style_buf;
-    const auto role_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ButtonRole role_buf = {};
-    role_buf.tag = role_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((role_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        role_buf.value = static_cast<Ark_ButtonRole>(valueDeserializer.readInt32());
-    }
-    value.role = role_buf;
-    const auto fontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length fontSize_buf = {};
-    fontSize_buf.tag = fontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto _left_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length _left_buf = {};
+    _left_buf.tag = _left_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_left_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Length fontSize_buf_ = {};
-        fontSize_buf_.selector = fontSize_buf__selector;
-        if (fontSize_buf__selector == 0) {
-            fontSize_buf_.selector = 0;
-            fontSize_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 _left_buf__selector = valueDeserializer.readInt8();
+        Ark_Length _left_buf_ = {};
+        _left_buf_.selector = _left_buf__selector;
+        if (_left_buf__selector == 0) {
+            _left_buf_.selector = 0;
+            _left_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (fontSize_buf__selector == 1) {
-            fontSize_buf_.selector = 1;
-            fontSize_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (_left_buf__selector == 1) {
+            _left_buf_.selector = 1;
+            _left_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (fontSize_buf__selector == 2) {
-            fontSize_buf_.selector = 2;
-            fontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (_left_buf__selector == 2) {
+            _left_buf_.selector = 2;
+            _left_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for fontSize_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _left_buf_ has to be chosen through deserialisation.");
         }
-        fontSize_buf.value = static_cast<Ark_Length>(fontSize_buf_);
+        _left_buf.value = static_cast<Ark_Length>(_left_buf_);
     }
-    value.fontSize = fontSize_buf;
-    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor fontColor_buf = {};
-    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._left = _left_buf;
+    const auto _top_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length _top_buf = {};
+    _top_buf.tag = _top_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_top_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor fontColor_buf_ = {};
-        fontColor_buf_.selector = fontColor_buf__selector;
-        if (fontColor_buf__selector == 0) {
-            fontColor_buf_.selector = 0;
-            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (fontColor_buf__selector == 1) {
-            fontColor_buf_.selector = 1;
-            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 _top_buf__selector = valueDeserializer.readInt8();
+        Ark_Length _top_buf_ = {};
+        _top_buf_.selector = _top_buf__selector;
+        if (_top_buf__selector == 0) {
+            _top_buf_.selector = 0;
+            _top_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (fontColor_buf__selector == 2) {
-            fontColor_buf_.selector = 2;
-            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (_top_buf__selector == 1) {
+            _top_buf_.selector = 1;
+            _top_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (fontColor_buf__selector == 3) {
-            fontColor_buf_.selector = 3;
-            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (_top_buf__selector == 2) {
+            _top_buf_.selector = 2;
+            _top_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _top_buf_ has to be chosen through deserialisation.");
         }
-        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
+        _top_buf.value = static_cast<Ark_Length>(_top_buf_);
     }
-    value.fontColor = fontColor_buf;
-    const auto fontWeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_FontWeight_Number_String fontWeight_buf = {};
-    fontWeight_buf.tag = fontWeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontWeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._top = _top_buf;
+    const auto _right_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length _right_buf = {};
+    _right_buf.tag = _right_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_right_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontWeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_FontWeight_Number_String fontWeight_buf_ = {};
-        fontWeight_buf_.selector = fontWeight_buf__selector;
-        if (fontWeight_buf__selector == 0) {
-            fontWeight_buf_.selector = 0;
-            fontWeight_buf_.value0 = static_cast<Ark_FontWeight>(valueDeserializer.readInt32());
+        const Ark_Int8 _right_buf__selector = valueDeserializer.readInt8();
+        Ark_Length _right_buf_ = {};
+        _right_buf_.selector = _right_buf__selector;
+        if (_right_buf__selector == 0) {
+            _right_buf_.selector = 0;
+            _right_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (fontWeight_buf__selector == 1) {
-            fontWeight_buf_.selector = 1;
-            fontWeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (_right_buf__selector == 1) {
+            _right_buf_.selector = 1;
+            _right_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (fontWeight_buf__selector == 2) {
-            fontWeight_buf_.selector = 2;
-            fontWeight_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (_right_buf__selector == 2) {
+            _right_buf_.selector = 2;
+            _right_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _right_buf_ has to be chosen through deserialisation.");
         }
-        fontWeight_buf.value = static_cast<Ark_Union_FontWeight_Number_String>(fontWeight_buf_);
-    }
-    value.fontWeight = fontWeight_buf;
-    const auto fontStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_FontStyle fontStyle_buf = {};
-    fontStyle_buf.tag = fontStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        fontStyle_buf.value = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
+        _right_buf.value = static_cast<Ark_Length>(_right_buf_);
     }
-    value.fontStyle = fontStyle_buf;
-    const auto fontFamily_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Resource_String fontFamily_buf = {};
-    fontFamily_buf.tag = fontFamily_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontFamily_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._right = _right_buf;
+    const auto _bottom_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length _bottom_buf = {};
+    _bottom_buf.tag = _bottom_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_bottom_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontFamily_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Resource_String fontFamily_buf_ = {};
-        fontFamily_buf_.selector = fontFamily_buf__selector;
-        if (fontFamily_buf__selector == 0) {
-            fontFamily_buf_.selector = 0;
-            fontFamily_buf_.value0 = Resource_serializer::read(valueDeserializer);
+        const Ark_Int8 _bottom_buf__selector = valueDeserializer.readInt8();
+        Ark_Length _bottom_buf_ = {};
+        _bottom_buf_.selector = _bottom_buf__selector;
+        if (_bottom_buf__selector == 0) {
+            _bottom_buf_.selector = 0;
+            _bottom_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (fontFamily_buf__selector == 1) {
-            fontFamily_buf_.selector = 1;
-            fontFamily_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (_bottom_buf__selector == 1) {
+            _bottom_buf_.selector = 1;
+            _bottom_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (_bottom_buf__selector == 2) {
+            _bottom_buf_.selector = 2;
+            _bottom_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _bottom_buf_ has to be chosen through deserialisation.");
         }
-        fontFamily_buf.value = static_cast<Ark_Union_Resource_String>(fontFamily_buf_);
+        _bottom_buf.value = static_cast<Ark_Length>(_bottom_buf_);
     }
-    value.fontFamily = fontFamily_buf;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._bottom = _bottom_buf;
+    const auto _start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LengthMetrics _start_buf = {};
+    _start_buf.tag = _start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        _start_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+    }
+    value._start = _start_buf;
+    const auto _end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LengthMetrics _end_buf = {};
+    _end_buf.tag = _end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _end_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+    }
+    value._end = _end_buf;
+    const auto _fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor _fontColor_buf = {};
+    _fontColor_buf.tag = _fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 _fontColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor _fontColor_buf_ = {};
+        _fontColor_buf_.selector = _fontColor_buf__selector;
+        if (_fontColor_buf__selector == 0) {
+            _fontColor_buf_.selector = 0;
+            _fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (_fontColor_buf__selector == 1) {
+            _fontColor_buf_.selector = 1;
+            _fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (_fontColor_buf__selector == 2) {
+            _fontColor_buf_.selector = 2;
+            _fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (_fontColor_buf__selector == 3) {
+            _fontColor_buf_.selector = 3;
+            _fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _fontColor_buf_ has to be chosen through deserialisation.");
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
+        _fontColor_buf.value = static_cast<Ark_ResourceColor>(_fontColor_buf_);
     }
-    value.backgroundColor = backgroundColor_buf;
-    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_BorderRadiuses borderRadius_buf = {};
-    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._fontColor = _fontColor_buf;
+    const auto _selectedFontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor _selectedFontColor_buf = {};
+    _selectedFontColor_buf.tag = _selectedFontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_selectedFontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_BorderRadiuses borderRadius_buf_ = {};
-        borderRadius_buf_.selector = borderRadius_buf__selector;
-        if (borderRadius_buf__selector == 0) {
-            borderRadius_buf_.selector = 0;
-            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length borderRadius_buf__u = {};
-            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
-            if (borderRadius_buf__u_selector == 0) {
-                borderRadius_buf__u.selector = 0;
-                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderRadius_buf__u_selector == 1) {
-                borderRadius_buf__u.selector = 1;
-                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderRadius_buf__u_selector == 2) {
-                borderRadius_buf__u.selector = 2;
-                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
+        const Ark_Int8 _selectedFontColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor _selectedFontColor_buf_ = {};
+        _selectedFontColor_buf_.selector = _selectedFontColor_buf__selector;
+        if (_selectedFontColor_buf__selector == 0) {
+            _selectedFontColor_buf_.selector = 0;
+            _selectedFontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (borderRadius_buf__selector == 1) {
-            borderRadius_buf_.selector = 1;
-            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        else if (_selectedFontColor_buf__selector == 1) {
+            _selectedFontColor_buf_.selector = 1;
+            _selectedFontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (_selectedFontColor_buf__selector == 2) {
+            _selectedFontColor_buf_.selector = 2;
+            _selectedFontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (_selectedFontColor_buf__selector == 3) {
+            _selectedFontColor_buf_.selector = 3;
+            _selectedFontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _selectedFontColor_buf_ has to be chosen through deserialisation.");
         }
-        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses>(borderRadius_buf_);
+        _selectedFontColor_buf.value = static_cast<Ark_ResourceColor>(_selectedFontColor_buf_);
     }
-    value.borderRadius = borderRadius_buf;
-    const auto primary_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean primary_buf = {};
-    primary_buf.tag = primary_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((primary_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._selectedFontColor = _selectedFontColor_buf;
+    const auto _digitFont_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font _digitFont_buf = {};
+    _digitFont_buf.tag = _digitFont_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_digitFont_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        primary_buf.value = valueDeserializer.readBoolean();
+        _digitFont_buf.value = Font_serializer::read(valueDeserializer);
     }
-    value.primary = primary_buf;
+    value._digitFont = _digitFont_buf;
+    const auto _selectedDigitFont_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font _selectedDigitFont_buf = {};
+    _selectedDigitFont_buf.tag = _selectedDigitFont_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_selectedDigitFont_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _selectedDigitFont_buf.value = Font_serializer::read(valueDeserializer);
+    }
+    value._selectedDigitFont = _selectedDigitFont_buf;
     return value;
 }
-inline void PickerTextStyle_serializer::write(SerializerBase& buffer, Ark_PickerTextStyle value)
+inline void EventTarget_serializer::write(SerializerBase& buffer, Ark_EventTarget value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_color = value.color;
-    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
-    value_color_type = runtimeType(value_color);
-    valueSerializer.writeInt8(value_color_type);
-    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_color_value = value_color.value;
-        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_color_value_type = value_color_value.selector;
-        if (value_color_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_color_value_0 = value_color_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0));
-        }
-        else if (value_color_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_color_value_1 = value_color_value.value1;
-            valueSerializer.writeNumber(value_color_value_1);
-        }
-        else if (value_color_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_color_value_2 = value_color_value.value2;
-            valueSerializer.writeString(value_color_value_2);
-        }
-        else if (value_color_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_color_value_3 = value_color_value.value3;
-            Resource_serializer::write(valueSerializer, value_color_value_3);
-        }
-    }
-    const auto value_font = value.font;
-    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
-    value_font_type = runtimeType(value_font);
-    valueSerializer.writeInt8(value_font_type);
-    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_font_value = value_font.value;
-        Font_serializer::write(valueSerializer, value_font_value);
+    const auto value_area = value.area;
+    Area_serializer::write(valueSerializer, value_area);
+    const auto value_id = value.id;
+    Ark_Int32 value_id_type = INTEROP_RUNTIME_UNDEFINED;
+    value_id_type = runtimeType(value_id);
+    valueSerializer.writeInt8(value_id_type);
+    if ((value_id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_id_value = value_id.value;
+        valueSerializer.writeString(value_id_value);
     }
 }
-inline Ark_PickerTextStyle PickerTextStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_EventTarget EventTarget_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PickerTextStyle value = {};
+    Ark_EventTarget value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor color_buf = {};
-    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor color_buf_ = {};
-        color_buf_.selector = color_buf__selector;
-        if (color_buf__selector == 0) {
-            color_buf_.selector = 0;
-            color_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (color_buf__selector == 1) {
-            color_buf_.selector = 1;
-            color_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (color_buf__selector == 2) {
-            color_buf_.selector = 2;
-            color_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (color_buf__selector == 3) {
-            color_buf_.selector = 3;
-            color_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
-        }
-        color_buf.value = static_cast<Ark_ResourceColor>(color_buf_);
-    }
-    value.color = color_buf;
-    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font font_buf = {};
-    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.area = Area_serializer::read(valueDeserializer);
+    const auto id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String id_buf = {};
+    id_buf.tag = id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        font_buf.value = Font_serializer::read(valueDeserializer);
+        id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.font = font_buf;
+    value.id = id_buf;
     return value;
 }
-inline void PinchGestureEvent_serializer::write(SerializerBase& buffer, Ark_PinchGestureEvent value)
+inline void FocusAxisEvent_serializer::write(SerializerBase& buffer, Ark_FocusAxisEvent value)
 {
     SerializerBase& valueSerializer = buffer;
     valueSerializer.writePointer(value);
 }
-inline Ark_PinchGestureEvent PinchGestureEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_FocusAxisEvent FocusAxisEvent_serializer::read(DeserializerBase& buffer)
 {
     DeserializerBase& valueDeserializer = buffer;
     Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_PinchGestureEvent>(ptr);
+    return static_cast<Ark_FocusAxisEvent>(ptr);
 }
-inline void PlaceholderStyle_serializer::write(SerializerBase& buffer, Ark_PlaceholderStyle value)
+inline void GeometryInfo_serializer::write(SerializerBase& buffer, Ark_GeometryInfo value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_font = value.font;
-    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
-    value_font_type = runtimeType(value_font);
-    valueSerializer.writeInt8(value_font_type);
-    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_font_value = value_font.value;
-        Font_serializer::write(valueSerializer, value_font_value);
-    }
-    const auto value_fontColor = value.fontColor;
-    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontColor_type = runtimeType(value_fontColor);
-    valueSerializer.writeInt8(value_fontColor_type);
-    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontColor_value = value_fontColor.value;
-        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontColor_value_type = value_fontColor_value.selector;
-        if (value_fontColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_fontColor_value_0 = value_fontColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
-        }
-        else if (value_fontColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_fontColor_value_1 = value_fontColor_value.value1;
-            valueSerializer.writeNumber(value_fontColor_value_1);
-        }
-        else if (value_fontColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_fontColor_value_2 = value_fontColor_value.value2;
-            valueSerializer.writeString(value_fontColor_value_2);
-        }
-        else if (value_fontColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_fontColor_value_3 = value_fontColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
-        }
-    }
+    const auto value_width = value.width;
+    valueSerializer.writeNumber(value_width);
+    const auto value_height = value.height;
+    valueSerializer.writeNumber(value_height);
+    const auto value_borderWidth = value.borderWidth;
+    EdgeWidths_serializer::write(valueSerializer, value_borderWidth);
+    const auto value_margin = value.margin;
+    Padding_serializer::write(valueSerializer, value_margin);
+    const auto value_padding = value.padding;
+    Padding_serializer::write(valueSerializer, value_padding);
 }
-inline Ark_PlaceholderStyle PlaceholderStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_GeometryInfo GeometryInfo_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PlaceholderStyle value = {};
+    Ark_GeometryInfo value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font font_buf = {};
-    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        font_buf.value = Font_serializer::read(valueDeserializer);
-    }
-    value.font = font_buf;
-    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor fontColor_buf = {};
-    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor fontColor_buf_ = {};
-        fontColor_buf_.selector = fontColor_buf__selector;
-        if (fontColor_buf__selector == 0) {
-            fontColor_buf_.selector = 0;
-            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (fontColor_buf__selector == 1) {
-            fontColor_buf_.selector = 1;
-            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (fontColor_buf__selector == 2) {
-            fontColor_buf_.selector = 2;
-            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (fontColor_buf__selector == 3) {
-            fontColor_buf_.selector = 3;
-            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
-        }
-        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
-    }
-    value.fontColor = fontColor_buf;
+    value.width = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.height = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.borderWidth = EdgeWidths_serializer::read(valueDeserializer);
+    value.margin = Padding_serializer::read(valueDeserializer);
+    value.padding = Padding_serializer::read(valueDeserializer);
     return value;
 }
-inline void PopupMessageOptions_serializer::write(SerializerBase& buffer, Ark_PopupMessageOptions value)
+inline void GestureEvent_serializer::write(SerializerBase& buffer, Ark_GestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_textColor = value.textColor;
-    Ark_Int32 value_textColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textColor_type = runtimeType(value_textColor);
-    valueSerializer.writeInt8(value_textColor_type);
-    if ((value_textColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textColor_value = value_textColor.value;
-        Ark_Int32 value_textColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_textColor_value_type = value_textColor_value.selector;
-        if (value_textColor_value_type == 0) {
+    valueSerializer.writePointer(value);
+}
+inline Ark_GestureEvent GestureEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_GestureEvent>(ptr);
+}
+inline void GutterOption_serializer::write(SerializerBase& buffer, Ark_GutterOption value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_x = value.x;
+    Ark_Int32 value_x_type = INTEROP_RUNTIME_UNDEFINED;
+    value_x_type = runtimeType(value_x);
+    valueSerializer.writeInt8(value_x_type);
+    if ((value_x_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_x_value = value_x.value;
+        Ark_Int32 value_x_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_x_value_type = value_x_value.selector;
+        if ((value_x_value_type == 0) || (value_x_value_type == 0) || (value_x_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_textColor_value_0 = value_textColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_textColor_value_0));
+            const auto value_x_value_0 = value_x_value.value0;
+            Ark_Int32 value_x_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_x_value_0_type = value_x_value_0.selector;
+            if (value_x_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_x_value_0_0 = value_x_value_0.value0;
+                valueSerializer.writeString(value_x_value_0_0);
+            }
+            else if (value_x_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_x_value_0_1 = value_x_value_0.value1;
+                valueSerializer.writeNumber(value_x_value_0_1);
+            }
+            else if (value_x_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_x_value_0_2 = value_x_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_x_value_0_2);
+            }
         }
-        else if (value_textColor_value_type == 1) {
+        else if (value_x_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_textColor_value_1 = value_textColor_value.value1;
-            valueSerializer.writeNumber(value_textColor_value_1);
+            const auto value_x_value_1 = value_x_value.value1;
+            GridRowSizeOption_serializer::write(valueSerializer, value_x_value_1);
         }
-        else if (value_textColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_textColor_value_2 = value_textColor_value.value2;
-            valueSerializer.writeString(value_textColor_value_2);
+    }
+    const auto value_y = value.y;
+    Ark_Int32 value_y_type = INTEROP_RUNTIME_UNDEFINED;
+    value_y_type = runtimeType(value_y);
+    valueSerializer.writeInt8(value_y_type);
+    if ((value_y_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_y_value = value_y.value;
+        Ark_Int32 value_y_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_y_value_type = value_y_value.selector;
+        if ((value_y_value_type == 0) || (value_y_value_type == 0) || (value_y_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_y_value_0 = value_y_value.value0;
+            Ark_Int32 value_y_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_y_value_0_type = value_y_value_0.selector;
+            if (value_y_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_y_value_0_0 = value_y_value_0.value0;
+                valueSerializer.writeString(value_y_value_0_0);
+            }
+            else if (value_y_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_y_value_0_1 = value_y_value_0.value1;
+                valueSerializer.writeNumber(value_y_value_0_1);
+            }
+            else if (value_y_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_y_value_0_2 = value_y_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_y_value_0_2);
+            }
         }
-        else if (value_textColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_textColor_value_3 = value_textColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_textColor_value_3);
+        else if (value_y_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_y_value_1 = value_y_value.value1;
+            GridRowSizeOption_serializer::write(valueSerializer, value_y_value_1);
         }
     }
-    const auto value_font = value.font;
-    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
-    value_font_type = runtimeType(value_font);
-    valueSerializer.writeInt8(value_font_type);
-    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_font_value = value_font.value;
-        Font_serializer::write(valueSerializer, value_font_value);
-    }
 }
-inline Ark_PopupMessageOptions PopupMessageOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_GutterOption GutterOption_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PopupMessageOptions value = {};
+    Ark_GutterOption value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto textColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor textColor_buf = {};
-    textColor_buf.tag = textColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto x_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_GridRowSizeOption x_buf = {};
+    x_buf.tag = x_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((x_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 textColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor textColor_buf_ = {};
-        textColor_buf_.selector = textColor_buf__selector;
-        if (textColor_buf__selector == 0) {
-            textColor_buf_.selector = 0;
-            textColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (textColor_buf__selector == 1) {
-            textColor_buf_.selector = 1;
-            textColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (textColor_buf__selector == 2) {
-            textColor_buf_.selector = 2;
-            textColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 x_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_GridRowSizeOption x_buf_ = {};
+        x_buf_.selector = x_buf__selector;
+        if (x_buf__selector == 0) {
+            x_buf_.selector = 0;
+            const Ark_Int8 x_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length x_buf__u = {};
+            x_buf__u.selector = x_buf__u_selector;
+            if (x_buf__u_selector == 0) {
+                x_buf__u.selector = 0;
+                x_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (x_buf__u_selector == 1) {
+                x_buf__u.selector = 1;
+                x_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (x_buf__u_selector == 2) {
+                x_buf__u.selector = 2;
+                x_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for x_buf__u has to be chosen through deserialisation.");
+            }
+            x_buf_.value0 = static_cast<Ark_Length>(x_buf__u);
         }
-        else if (textColor_buf__selector == 3) {
-            textColor_buf_.selector = 3;
-            textColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (x_buf__selector == 1) {
+            x_buf_.selector = 1;
+            x_buf_.value1 = GridRowSizeOption_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for textColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for x_buf_ has to be chosen through deserialisation.");
         }
-        textColor_buf.value = static_cast<Ark_ResourceColor>(textColor_buf_);
+        x_buf.value = static_cast<Ark_Union_Length_GridRowSizeOption>(x_buf_);
     }
-    value.textColor = textColor_buf;
-    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font font_buf = {};
-    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.x = x_buf;
+    const auto y_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_GridRowSizeOption y_buf = {};
+    y_buf.tag = y_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((y_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        font_buf.value = Font_serializer::read(valueDeserializer);
+        const Ark_Int8 y_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_GridRowSizeOption y_buf_ = {};
+        y_buf_.selector = y_buf__selector;
+        if (y_buf__selector == 0) {
+            y_buf_.selector = 0;
+            const Ark_Int8 y_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length y_buf__u = {};
+            y_buf__u.selector = y_buf__u_selector;
+            if (y_buf__u_selector == 0) {
+                y_buf__u.selector = 0;
+                y_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (y_buf__u_selector == 1) {
+                y_buf__u.selector = 1;
+                y_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (y_buf__u_selector == 2) {
+                y_buf__u.selector = 2;
+                y_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for y_buf__u has to be chosen through deserialisation.");
+            }
+            y_buf_.value0 = static_cast<Ark_Length>(y_buf__u);
+        }
+        else if (y_buf__selector == 1) {
+            y_buf_.selector = 1;
+            y_buf_.value1 = GridRowSizeOption_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for y_buf_ has to be chosen through deserialisation.");
+        }
+        y_buf.value = static_cast<Ark_Union_Length_GridRowSizeOption>(y_buf_);
     }
-    value.font = font_buf;
+    value.y = y_buf;
     return value;
 }
-inline void ResizableOptions_serializer::write(SerializerBase& buffer, Ark_ResizableOptions value)
+inline void HoverEvent_serializer::write(SerializerBase& buffer, Ark_HoverEvent value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_slice = value.slice;
-    Ark_Int32 value_slice_type = INTEROP_RUNTIME_UNDEFINED;
-    value_slice_type = runtimeType(value_slice);
-    valueSerializer.writeInt8(value_slice_type);
-    if ((value_slice_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_slice_value = value_slice.value;
-        EdgeWidths_serializer::write(valueSerializer, value_slice_value);
-    }
-    const auto value_lattice = value.lattice;
-    Ark_Int32 value_lattice_type = INTEROP_RUNTIME_UNDEFINED;
-    value_lattice_type = runtimeType(value_lattice);
-    valueSerializer.writeInt8(value_lattice_type);
-    if ((value_lattice_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_lattice_value = value_lattice.value;
-        drawing_Lattice_serializer::write(valueSerializer, value_lattice_value);
-    }
+    valueSerializer.writePointer(value);
 }
-inline Ark_ResizableOptions ResizableOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_HoverEvent HoverEvent_serializer::read(DeserializerBase& buffer)
 {
-    Ark_ResizableOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto slice_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_EdgeWidths slice_buf = {};
-    slice_buf.tag = slice_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((slice_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        slice_buf.value = EdgeWidths_serializer::read(valueDeserializer);
-    }
-    value.slice = slice_buf;
-    const auto lattice_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_drawing_Lattice lattice_buf = {};
-    lattice_buf.tag = lattice_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((lattice_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        lattice_buf.value = static_cast<Ark_drawing_Lattice>(drawing_Lattice_serializer::read(valueDeserializer));
-    }
-    value.lattice = lattice_buf;
-    return value;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_HoverEvent>(ptr);
 }
-inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorLayoutStyle value)
+inline void ImageAttachmentLayoutStyle_serializer::write(SerializerBase& buffer, Ark_ImageAttachmentLayoutStyle value)
 {
     SerializerBase& valueSerializer = buffer;
     const auto value_margin = value.margin;
@@ -107478,26 +109645,10 @@ inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_
         const auto value_margin_value = value_margin.value;
         Ark_Int32 value_margin_value_type = INTEROP_RUNTIME_UNDEFINED;
         value_margin_value_type = value_margin_value.selector;
-        if ((value_margin_value_type == 0) || (value_margin_value_type == 0) || (value_margin_value_type == 0)) {
+        if (value_margin_value_type == 0) {
             valueSerializer.writeInt8(0);
             const auto value_margin_value_0 = value_margin_value.value0;
-            Ark_Int32 value_margin_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_margin_value_0_type = value_margin_value_0.selector;
-            if (value_margin_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_margin_value_0_0 = value_margin_value_0.value0;
-                valueSerializer.writeString(value_margin_value_0_0);
-            }
-            else if (value_margin_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_margin_value_0_1 = value_margin_value_0.value1;
-                valueSerializer.writeNumber(value_margin_value_0_1);
-            }
-            else if (value_margin_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_margin_value_0_2 = value_margin_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_margin_value_0_2);
-            }
+            LengthMetrics_serializer::write(valueSerializer, value_margin_value_0);
         }
         else if (value_margin_value_type == 1) {
             valueSerializer.writeInt8(1);
@@ -107505,6 +109656,25 @@ inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_
             Padding_serializer::write(valueSerializer, value_margin_value_1);
         }
     }
+    const auto value_padding = value.padding;
+    Ark_Int32 value_padding_type = INTEROP_RUNTIME_UNDEFINED;
+    value_padding_type = runtimeType(value_padding);
+    valueSerializer.writeInt8(value_padding_type);
+    if ((value_padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_padding_value = value_padding.value;
+        Ark_Int32 value_padding_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_padding_value_type = value_padding_value.selector;
+        if (value_padding_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_padding_value_0 = value_padding_value.value0;
+            LengthMetrics_serializer::write(valueSerializer, value_padding_value_0);
+        }
+        else if (value_padding_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_padding_value_1 = value_padding_value.value1;
+            Padding_serializer::write(valueSerializer, value_padding_value_1);
+        }
+    }
     const auto value_borderRadius = value.borderRadius;
     Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
     value_borderRadius_type = runtimeType(value_borderRadius);
@@ -107513,26 +109683,10 @@ inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_
         const auto value_borderRadius_value = value_borderRadius.value;
         Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
         value_borderRadius_value_type = value_borderRadius_value.selector;
-        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
+        if (value_borderRadius_value_type == 0) {
             valueSerializer.writeInt8(0);
             const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
-            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
-            if (value_borderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
-                valueSerializer.writeString(value_borderRadius_value_0_0);
-            }
-            else if (value_borderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_borderRadius_value_0_1);
-            }
-            else if (value_borderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
-            }
+            LengthMetrics_serializer::write(valueSerializer, value_borderRadius_value_0);
         }
         else if (value_borderRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
@@ -107541,39 +109695,21 @@ inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_
         }
     }
 }
-inline Ark_RichEditorLayoutStyle RichEditorLayoutStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_ImageAttachmentLayoutStyle ImageAttachmentLayoutStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_RichEditorLayoutStyle value = {};
+    Ark_ImageAttachmentLayoutStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
     const auto margin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_Margin margin_buf = {};
+    Opt_Union_LengthMetrics_Margin margin_buf = {};
     margin_buf.tag = margin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((margin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
         const Ark_Int8 margin_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_Margin margin_buf_ = {};
+        Ark_Union_LengthMetrics_Margin margin_buf_ = {};
         margin_buf_.selector = margin_buf__selector;
         if (margin_buf__selector == 0) {
             margin_buf_.selector = 0;
-            const Ark_Int8 margin_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension margin_buf__u = {};
-            margin_buf__u.selector = margin_buf__u_selector;
-            if (margin_buf__u_selector == 0) {
-                margin_buf__u.selector = 0;
-                margin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (margin_buf__u_selector == 1) {
-                margin_buf__u.selector = 1;
-                margin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (margin_buf__u_selector == 2) {
-                margin_buf__u.selector = 2;
-                margin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for margin_buf__u has to be chosen through deserialisation.");
-            }
-            margin_buf_.value0 = static_cast<Ark_Dimension>(margin_buf__u);
+            margin_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
         }
         else if (margin_buf__selector == 1) {
             margin_buf_.selector = 1;
@@ -107582,38 +109718,42 @@ inline Ark_RichEditorLayoutStyle RichEditorLayoutStyle_serializer::read(Deserial
         else {
             INTEROP_FATAL("One of the branches for margin_buf_ has to be chosen through deserialisation.");
         }
-        margin_buf.value = static_cast<Ark_Union_Dimension_Margin>(margin_buf_);
+        margin_buf.value = static_cast<Ark_Union_LengthMetrics_Margin>(margin_buf_);
     }
     value.margin = margin_buf;
+    const auto padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_LengthMetrics_Padding padding_buf = {};
+    padding_buf.tag = padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 padding_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_LengthMetrics_Padding padding_buf_ = {};
+        padding_buf_.selector = padding_buf__selector;
+        if (padding_buf__selector == 0) {
+            padding_buf_.selector = 0;
+            padding_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        }
+        else if (padding_buf__selector == 1) {
+            padding_buf_.selector = 1;
+            padding_buf_.value1 = Padding_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for padding_buf_ has to be chosen through deserialisation.");
+        }
+        padding_buf.value = static_cast<Ark_Union_LengthMetrics_Padding>(padding_buf_);
+    }
+    value.padding = padding_buf;
     const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_BorderRadiuses borderRadius_buf = {};
+    Opt_Union_LengthMetrics_BorderRadiuses borderRadius_buf = {};
     borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
         const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_BorderRadiuses borderRadius_buf_ = {};
+        Ark_Union_LengthMetrics_BorderRadiuses borderRadius_buf_ = {};
         borderRadius_buf_.selector = borderRadius_buf__selector;
         if (borderRadius_buf__selector == 0) {
             borderRadius_buf_.selector = 0;
-            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension borderRadius_buf__u = {};
-            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
-            if (borderRadius_buf__u_selector == 0) {
-                borderRadius_buf__u.selector = 0;
-                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderRadius_buf__u_selector == 1) {
-                borderRadius_buf__u.selector = 1;
-                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderRadius_buf__u_selector == 2) {
-                borderRadius_buf__u.selector = 2;
-                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            borderRadius_buf_.value0 = static_cast<Ark_Dimension>(borderRadius_buf__u);
+            borderRadius_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
         }
         else if (borderRadius_buf__selector == 1) {
             borderRadius_buf_.selector = 1;
@@ -107622,468 +109762,183 @@ inline Ark_RichEditorLayoutStyle RichEditorLayoutStyle_serializer::read(Deserial
         else {
             INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
         }
-        borderRadius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(borderRadius_buf_);
+        borderRadius_buf.value = static_cast<Ark_Union_LengthMetrics_BorderRadiuses>(borderRadius_buf_);
     }
     value.borderRadius = borderRadius_buf;
     return value;
 }
-inline void RichEditorParagraphStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphStyle value)
+inline void LayoutChild_serializer::write(SerializerBase& buffer, Ark_LayoutChild value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_textAlign = value.textAlign;
-    Ark_Int32 value_textAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textAlign_type = runtimeType(value_textAlign);
-    valueSerializer.writeInt8(value_textAlign_type);
-    if ((value_textAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textAlign_value = value_textAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextAlign>(value_textAlign_value));
-    }
-    const auto value_leadingMargin = value.leadingMargin;
-    Ark_Int32 value_leadingMargin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_leadingMargin_type = runtimeType(value_leadingMargin);
-    valueSerializer.writeInt8(value_leadingMargin_type);
-    if ((value_leadingMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_leadingMargin_value = value_leadingMargin.value;
-        Ark_Int32 value_leadingMargin_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_leadingMargin_value_type = value_leadingMargin_value.selector;
-        if ((value_leadingMargin_value_type == 0) || (value_leadingMargin_value_type == 0) || (value_leadingMargin_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_leadingMargin_value_0 = value_leadingMargin_value.value0;
-            Ark_Int32 value_leadingMargin_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_leadingMargin_value_0_type = value_leadingMargin_value_0.selector;
-            if (value_leadingMargin_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_leadingMargin_value_0_0 = value_leadingMargin_value_0.value0;
-                valueSerializer.writeString(value_leadingMargin_value_0_0);
-            }
-            else if (value_leadingMargin_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_leadingMargin_value_0_1 = value_leadingMargin_value_0.value1;
-                valueSerializer.writeNumber(value_leadingMargin_value_0_1);
-            }
-            else if (value_leadingMargin_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_leadingMargin_value_0_2 = value_leadingMargin_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_leadingMargin_value_0_2);
-            }
-        }
-        else if (value_leadingMargin_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_leadingMargin_value_1 = value_leadingMargin_value.value1;
-            LeadingMarginPlaceholder_serializer::write(valueSerializer, value_leadingMargin_value_1);
-        }
-    }
-    const auto value_wordBreak = value.wordBreak;
-    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
-    value_wordBreak_type = runtimeType(value_wordBreak);
-    valueSerializer.writeInt8(value_wordBreak_type);
-    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_wordBreak_value = value_wordBreak.value;
-        valueSerializer.writeInt32(static_cast<Ark_WordBreak>(value_wordBreak_value));
-    }
-    const auto value_lineBreakStrategy = value.lineBreakStrategy;
-    Ark_Int32 value_lineBreakStrategy_type = INTEROP_RUNTIME_UNDEFINED;
-    value_lineBreakStrategy_type = runtimeType(value_lineBreakStrategy);
-    valueSerializer.writeInt8(value_lineBreakStrategy_type);
-    if ((value_lineBreakStrategy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_lineBreakStrategy_value = value_lineBreakStrategy.value;
-        valueSerializer.writeInt32(static_cast<Ark_LineBreakStrategy>(value_lineBreakStrategy_value));
-    }
-    const auto value_paragraphSpacing = value.paragraphSpacing;
-    Ark_Int32 value_paragraphSpacing_type = INTEROP_RUNTIME_UNDEFINED;
-    value_paragraphSpacing_type = runtimeType(value_paragraphSpacing);
-    valueSerializer.writeInt8(value_paragraphSpacing_type);
-    if ((value_paragraphSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_paragraphSpacing_value = value_paragraphSpacing.value;
-        valueSerializer.writeNumber(value_paragraphSpacing_value);
-    }
-}
-inline Ark_RichEditorParagraphStyle RichEditorParagraphStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorParagraphStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto textAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextAlign textAlign_buf = {};
-    textAlign_buf.tag = textAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textAlign_buf.value = static_cast<Ark_TextAlign>(valueDeserializer.readInt32());
-    }
-    value.textAlign = textAlign_buf;
-    const auto leadingMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_LeadingMarginPlaceholder leadingMargin_buf = {};
-    leadingMargin_buf.tag = leadingMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((leadingMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 leadingMargin_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_LeadingMarginPlaceholder leadingMargin_buf_ = {};
-        leadingMargin_buf_.selector = leadingMargin_buf__selector;
-        if (leadingMargin_buf__selector == 0) {
-            leadingMargin_buf_.selector = 0;
-            const Ark_Int8 leadingMargin_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension leadingMargin_buf__u = {};
-            leadingMargin_buf__u.selector = leadingMargin_buf__u_selector;
-            if (leadingMargin_buf__u_selector == 0) {
-                leadingMargin_buf__u.selector = 0;
-                leadingMargin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (leadingMargin_buf__u_selector == 1) {
-                leadingMargin_buf__u.selector = 1;
-                leadingMargin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (leadingMargin_buf__u_selector == 2) {
-                leadingMargin_buf__u.selector = 2;
-                leadingMargin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for leadingMargin_buf__u has to be chosen through deserialisation.");
-            }
-            leadingMargin_buf_.value0 = static_cast<Ark_Dimension>(leadingMargin_buf__u);
-        }
-        else if (leadingMargin_buf__selector == 1) {
-            leadingMargin_buf_.selector = 1;
-            leadingMargin_buf_.value1 = LeadingMarginPlaceholder_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for leadingMargin_buf_ has to be chosen through deserialisation.");
-        }
-        leadingMargin_buf.value = static_cast<Ark_Union_Dimension_LeadingMarginPlaceholder>(leadingMargin_buf_);
-    }
-    value.leadingMargin = leadingMargin_buf;
-    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_WordBreak wordBreak_buf = {};
-    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        wordBreak_buf.value = static_cast<Ark_WordBreak>(valueDeserializer.readInt32());
-    }
-    value.wordBreak = wordBreak_buf;
-    const auto lineBreakStrategy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LineBreakStrategy lineBreakStrategy_buf = {};
-    lineBreakStrategy_buf.tag = lineBreakStrategy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((lineBreakStrategy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        lineBreakStrategy_buf.value = static_cast<Ark_LineBreakStrategy>(valueDeserializer.readInt32());
-    }
-    value.lineBreakStrategy = lineBreakStrategy_buf;
-    const auto paragraphSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number paragraphSpacing_buf = {};
-    paragraphSpacing_buf.tag = paragraphSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((paragraphSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        paragraphSpacing_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.paragraphSpacing = paragraphSpacing_buf;
-    return value;
-}
-inline void RichEditorParagraphStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphStyleOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_start = value.start;
-    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
-    value_start_type = runtimeType(value_start);
-    valueSerializer.writeInt8(value_start_type);
-    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_start_value = value_start.value;
-        valueSerializer.writeNumber(value_start_value);
-    }
-    const auto value_end = value.end;
-    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
-    value_end_type = runtimeType(value_end);
-    valueSerializer.writeInt8(value_end_type);
-    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_end_value = value_end.value;
-        valueSerializer.writeNumber(value_end_value);
-    }
-    const auto value_style = value.style;
-    RichEditorParagraphStyle_serializer::write(valueSerializer, value_style);
+    valueSerializer.writePointer(value);
 }
-inline Ark_RichEditorParagraphStyleOptions RichEditorParagraphStyleOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_LayoutChild LayoutChild_serializer::read(DeserializerBase& buffer)
 {
-    Ark_RichEditorParagraphStyleOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.start = start_buf;
-    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number end_buf = {};
-    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.end = end_buf;
-    value.style = RichEditorParagraphStyle_serializer::read(valueDeserializer);
-    return value;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_LayoutChild>(ptr);
 }
-inline void RotationGestureEvent_serializer::write(SerializerBase& buffer, Ark_RotationGestureEvent value)
+inline void LongPressGestureEvent_serializer::write(SerializerBase& buffer, Ark_LongPressGestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
     valueSerializer.writePointer(value);
 }
-inline Ark_RotationGestureEvent RotationGestureEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_LongPressGestureEvent LongPressGestureEvent_serializer::read(DeserializerBase& buffer)
 {
     DeserializerBase& valueDeserializer = buffer;
     Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_RotationGestureEvent>(ptr);
+    return static_cast<Ark_LongPressGestureEvent>(ptr);
 }
-inline void SectionOptions_serializer::write(SerializerBase& buffer, Ark_SectionOptions value)
+inline void MenuOptions_serializer::write(SerializerBase& buffer, Ark_MenuOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_itemsCount = value.itemsCount;
-    valueSerializer.writeNumber(value_itemsCount);
-    const auto value_crossCount = value.crossCount;
-    Ark_Int32 value_crossCount_type = INTEROP_RUNTIME_UNDEFINED;
-    value_crossCount_type = runtimeType(value_crossCount);
-    valueSerializer.writeInt8(value_crossCount_type);
-    if ((value_crossCount_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_crossCount_value = value_crossCount.value;
-        valueSerializer.writeNumber(value_crossCount_value);
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Position_serializer::write(valueSerializer, value_offset_value);
     }
-    const auto value_onGetItemMainSizeByIndex = value.onGetItemMainSizeByIndex;
-    Ark_Int32 value_onGetItemMainSizeByIndex_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onGetItemMainSizeByIndex_type = runtimeType(value_onGetItemMainSizeByIndex);
-    valueSerializer.writeInt8(value_onGetItemMainSizeByIndex_type);
-    if ((value_onGetItemMainSizeByIndex_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onGetItemMainSizeByIndex_value = value_onGetItemMainSizeByIndex.value;
-        valueSerializer.writeCallbackResource(value_onGetItemMainSizeByIndex_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onGetItemMainSizeByIndex_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onGetItemMainSizeByIndex_value.callSync));
+    const auto value_placement = value.placement;
+    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placement_type = runtimeType(value_placement);
+    valueSerializer.writeInt8(value_placement_type);
+    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placement_value = value_placement.value;
+        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
     }
-    const auto value_columnsGap = value.columnsGap;
-    Ark_Int32 value_columnsGap_type = INTEROP_RUNTIME_UNDEFINED;
-    value_columnsGap_type = runtimeType(value_columnsGap);
-    valueSerializer.writeInt8(value_columnsGap_type);
-    if ((value_columnsGap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_columnsGap_value = value_columnsGap.value;
-        Ark_Int32 value_columnsGap_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_columnsGap_value_type = value_columnsGap_value.selector;
-        if (value_columnsGap_value_type == 0) {
+    const auto value_enableArrow = value.enableArrow;
+    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableArrow_type = runtimeType(value_enableArrow);
+    valueSerializer.writeInt8(value_enableArrow_type);
+    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableArrow_value = value_enableArrow.value;
+        valueSerializer.writeBoolean(value_enableArrow_value);
+    }
+    const auto value_arrowOffset = value.arrowOffset;
+    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowOffset_type = runtimeType(value_arrowOffset);
+    valueSerializer.writeInt8(value_arrowOffset_type);
+    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowOffset_value = value_arrowOffset.value;
+        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowOffset_value_type = value_arrowOffset_value.selector;
+        if (value_arrowOffset_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_columnsGap_value_0 = value_columnsGap_value.value0;
-            valueSerializer.writeString(value_columnsGap_value_0);
+            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
+            valueSerializer.writeString(value_arrowOffset_value_0);
         }
-        else if (value_columnsGap_value_type == 1) {
+        else if (value_arrowOffset_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_columnsGap_value_1 = value_columnsGap_value.value1;
-            valueSerializer.writeNumber(value_columnsGap_value_1);
+            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
+            valueSerializer.writeNumber(value_arrowOffset_value_1);
         }
-        else if (value_columnsGap_value_type == 2) {
+        else if (value_arrowOffset_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_columnsGap_value_2 = value_columnsGap_value.value2;
-            Resource_serializer::write(valueSerializer, value_columnsGap_value_2);
+            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
         }
     }
-    const auto value_rowsGap = value.rowsGap;
-    Ark_Int32 value_rowsGap_type = INTEROP_RUNTIME_UNDEFINED;
-    value_rowsGap_type = runtimeType(value_rowsGap);
-    valueSerializer.writeInt8(value_rowsGap_type);
-    if ((value_rowsGap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_rowsGap_value = value_rowsGap.value;
-        Ark_Int32 value_rowsGap_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_rowsGap_value_type = value_rowsGap_value.selector;
-        if (value_rowsGap_value_type == 0) {
+    const auto value_preview = value.preview;
+    Ark_Int32 value_preview_type = INTEROP_RUNTIME_UNDEFINED;
+    value_preview_type = runtimeType(value_preview);
+    valueSerializer.writeInt8(value_preview_type);
+    if ((value_preview_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_preview_value = value_preview.value;
+        Ark_Int32 value_preview_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_preview_value_type = value_preview_value.selector;
+        if (value_preview_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_rowsGap_value_0 = value_rowsGap_value.value0;
-            valueSerializer.writeString(value_rowsGap_value_0);
+            const auto value_preview_value_0 = value_preview_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_MenuPreviewMode>(value_preview_value_0));
         }
-        else if (value_rowsGap_value_type == 1) {
+        else if (value_preview_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_rowsGap_value_1 = value_rowsGap_value.value1;
-            valueSerializer.writeNumber(value_rowsGap_value_1);
-        }
-        else if (value_rowsGap_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_rowsGap_value_2 = value_rowsGap_value.value2;
-            Resource_serializer::write(valueSerializer, value_rowsGap_value_2);
+            const auto value_preview_value_1 = value_preview_value.value1;
+            valueSerializer.writeCallbackResource(value_preview_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.callSync));
         }
     }
-    const auto value_margin = value.margin;
-    Ark_Int32 value_margin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_margin_type = runtimeType(value_margin);
-    valueSerializer.writeInt8(value_margin_type);
-    if ((value_margin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_margin_value = value_margin.value;
-        Ark_Int32 value_margin_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_margin_value_type = value_margin_value.selector;
-        if (value_margin_value_type == 0) {
+    const auto value_previewBorderRadius = value.previewBorderRadius;
+    Ark_Int32 value_previewBorderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_previewBorderRadius_type = runtimeType(value_previewBorderRadius);
+    valueSerializer.writeInt8(value_previewBorderRadius_type);
+    if ((value_previewBorderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_previewBorderRadius_value = value_previewBorderRadius.value;
+        Ark_Int32 value_previewBorderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_previewBorderRadius_value_type = value_previewBorderRadius_value.selector;
+        if ((value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_margin_value_0 = value_margin_value.value0;
-            Padding_serializer::write(valueSerializer, value_margin_value_0);
-        }
-        else if ((value_margin_value_type == 1) || (value_margin_value_type == 1) || (value_margin_value_type == 1)) {
-            valueSerializer.writeInt8(1);
-            const auto value_margin_value_1 = value_margin_value.value1;
-            Ark_Int32 value_margin_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_margin_value_1_type = value_margin_value_1.selector;
-            if (value_margin_value_1_type == 0) {
+            const auto value_previewBorderRadius_value_0 = value_previewBorderRadius_value.value0;
+            Ark_Int32 value_previewBorderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_previewBorderRadius_value_0_type = value_previewBorderRadius_value_0.selector;
+            if (value_previewBorderRadius_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_margin_value_1_0 = value_margin_value_1.value0;
-                valueSerializer.writeString(value_margin_value_1_0);
+                const auto value_previewBorderRadius_value_0_0 = value_previewBorderRadius_value_0.value0;
+                valueSerializer.writeString(value_previewBorderRadius_value_0_0);
             }
-            else if (value_margin_value_1_type == 1) {
+            else if (value_previewBorderRadius_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_margin_value_1_1 = value_margin_value_1.value1;
-                valueSerializer.writeNumber(value_margin_value_1_1);
+                const auto value_previewBorderRadius_value_0_1 = value_previewBorderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_previewBorderRadius_value_0_1);
             }
-            else if (value_margin_value_1_type == 2) {
+            else if (value_previewBorderRadius_value_0_type == 2) {
                 valueSerializer.writeInt8(2);
-                const auto value_margin_value_1_2 = value_margin_value_1.value2;
-                Resource_serializer::write(valueSerializer, value_margin_value_1_2);
+                const auto value_previewBorderRadius_value_0_2 = value_previewBorderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_previewBorderRadius_value_0_2);
             }
         }
-    }
-}
-inline Ark_SectionOptions SectionOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_SectionOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.itemsCount = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    const auto crossCount_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number crossCount_buf = {};
-    crossCount_buf.tag = crossCount_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((crossCount_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        crossCount_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.crossCount = crossCount_buf;
-    const auto onGetItemMainSizeByIndex_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_GetItemMainSizeByIndex onGetItemMainSizeByIndex_buf = {};
-    onGetItemMainSizeByIndex_buf.tag = onGetItemMainSizeByIndex_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onGetItemMainSizeByIndex_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onGetItemMainSizeByIndex_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number index, const Callback_Number_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_GetItemMainSizeByIndex)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number index, const Callback_Number_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_GetItemMainSizeByIndex))))};
-    }
-    value.onGetItemMainSizeByIndex = onGetItemMainSizeByIndex_buf;
-    const auto columnsGap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension columnsGap_buf = {};
-    columnsGap_buf.tag = columnsGap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((columnsGap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 columnsGap_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension columnsGap_buf_ = {};
-        columnsGap_buf_.selector = columnsGap_buf__selector;
-        if (columnsGap_buf__selector == 0) {
-            columnsGap_buf_.selector = 0;
-            columnsGap_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (columnsGap_buf__selector == 1) {
-            columnsGap_buf_.selector = 1;
-            columnsGap_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (columnsGap_buf__selector == 2) {
-            columnsGap_buf_.selector = 2;
-            columnsGap_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for columnsGap_buf_ has to be chosen through deserialisation.");
-        }
-        columnsGap_buf.value = static_cast<Ark_Dimension>(columnsGap_buf_);
-    }
-    value.columnsGap = columnsGap_buf;
-    const auto rowsGap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension rowsGap_buf = {};
-    rowsGap_buf.tag = rowsGap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((rowsGap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 rowsGap_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension rowsGap_buf_ = {};
-        rowsGap_buf_.selector = rowsGap_buf__selector;
-        if (rowsGap_buf__selector == 0) {
-            rowsGap_buf_.selector = 0;
-            rowsGap_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (rowsGap_buf__selector == 1) {
-            rowsGap_buf_.selector = 1;
-            rowsGap_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (rowsGap_buf__selector == 2) {
-            rowsGap_buf_.selector = 2;
-            rowsGap_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (value_previewBorderRadius_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_previewBorderRadius_value_1 = value_previewBorderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for rowsGap_buf_ has to be chosen through deserialisation.");
+        else if (value_previewBorderRadius_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_previewBorderRadius_value_2 = value_previewBorderRadius_value.value2;
+            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_2);
         }
-        rowsGap_buf.value = static_cast<Ark_Dimension>(rowsGap_buf_);
     }
-    value.rowsGap = rowsGap_buf;
-    const auto margin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Margin_Dimension margin_buf = {};
-    margin_buf.tag = margin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((margin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 margin_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Margin_Dimension margin_buf_ = {};
-        margin_buf_.selector = margin_buf__selector;
-        if (margin_buf__selector == 0) {
-            margin_buf_.selector = 0;
-            margin_buf_.value0 = Padding_serializer::read(valueDeserializer);
-        }
-        else if (margin_buf__selector == 1) {
-            margin_buf_.selector = 1;
-            const Ark_Int8 margin_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension margin_buf__u = {};
-            margin_buf__u.selector = margin_buf__u_selector;
-            if (margin_buf__u_selector == 0) {
-                margin_buf__u.selector = 0;
-                margin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (margin_buf__u_selector == 1) {
-                margin_buf__u.selector = 1;
-                margin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto value_borderRadius = value.borderRadius;
+    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderRadius_type = runtimeType(value_borderRadius);
+    valueSerializer.writeInt8(value_borderRadius_type);
+    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderRadius_value = value_borderRadius.value;
+        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderRadius_value_type = value_borderRadius_value.selector;
+        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
+            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
+            if (value_borderRadius_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
+                valueSerializer.writeString(value_borderRadius_value_0_0);
             }
-            else if (margin_buf__u_selector == 2) {
-                margin_buf__u.selector = 2;
-                margin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (value_borderRadius_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_borderRadius_value_0_1);
             }
-            else {
-                INTEROP_FATAL("One of the branches for margin_buf__u has to be chosen through deserialisation.");
+            else if (value_borderRadius_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
             }
-            margin_buf_.value1 = static_cast<Ark_Dimension>(margin_buf__u);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for margin_buf_ has to be chosen through deserialisation.");
-        }
-        margin_buf.value = static_cast<Ark_Union_Margin_Dimension>(margin_buf_);
-    }
-    value.margin = margin_buf;
-    return value;
-}
-inline void SheetOptions_serializer::write(SerializerBase& buffer, Ark_SheetOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_borderRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
+            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
         }
-        else if (value_backgroundColor_value_type == 2) {
+        else if (value_borderRadius_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
-        }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_borderRadius_value_2 = value_borderRadius_value.value2;
+            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_2);
         }
     }
     const auto value_onAppear = value.onAppear;
@@ -108106,238 +109961,193 @@ inline void SheetOptions_serializer::write(SerializerBase& buffer, Ark_SheetOpti
         valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
         valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
     }
-    const auto value_onWillAppear = value.onWillAppear;
-    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillAppear_type = runtimeType(value_onWillAppear);
-    valueSerializer.writeInt8(value_onWillAppear_type);
-    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillAppear_value = value_onWillAppear.value;
-        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    const auto value_aboutToAppear = value.aboutToAppear;
+    Ark_Int32 value_aboutToAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_aboutToAppear_type = runtimeType(value_aboutToAppear);
+    valueSerializer.writeInt8(value_aboutToAppear_type);
+    if ((value_aboutToAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_aboutToAppear_value = value_aboutToAppear.value;
+        valueSerializer.writeCallbackResource(value_aboutToAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.callSync));
     }
-    const auto value_onWillDisappear = value.onWillDisappear;
-    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
-    valueSerializer.writeInt8(value_onWillDisappear_type);
-    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDisappear_value = value_onWillDisappear.value;
-        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    const auto value_aboutToDisappear = value.aboutToDisappear;
+    Ark_Int32 value_aboutToDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_aboutToDisappear_type = runtimeType(value_aboutToDisappear);
+    valueSerializer.writeInt8(value_aboutToDisappear_type);
+    if ((value_aboutToDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_aboutToDisappear_value = value_aboutToDisappear.value;
+        valueSerializer.writeCallbackResource(value_aboutToDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.callSync));
     }
-    const auto value_height = value.height;
-    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
-    value_height_type = runtimeType(value_height);
-    valueSerializer.writeInt8(value_height_type);
-    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_height_value = value_height.value;
-        Ark_Int32 value_height_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_height_value_type = value_height_value.selector;
-        if (value_height_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_height_value_0 = value_height_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_height_value_0));
-        }
-        else if ((value_height_value_type == 1) || (value_height_value_type == 1) || (value_height_value_type == 1)) {
-            valueSerializer.writeInt8(1);
-            const auto value_height_value_1 = value_height_value.value1;
-            Ark_Int32 value_height_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_height_value_1_type = value_height_value_1.selector;
-            if (value_height_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_height_value_1_0 = value_height_value_1.value0;
-                valueSerializer.writeString(value_height_value_1_0);
-            }
-            else if (value_height_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_height_value_1_1 = value_height_value_1.value1;
-                valueSerializer.writeNumber(value_height_value_1_1);
-            }
-            else if (value_height_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_height_value_1_2 = value_height_value_1.value2;
-                Resource_serializer::write(valueSerializer, value_height_value_1_2);
-            }
-        }
+    const auto value_layoutRegionMargin = value.layoutRegionMargin;
+    Ark_Int32 value_layoutRegionMargin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin);
+    valueSerializer.writeInt8(value_layoutRegionMargin_type);
+    if ((value_layoutRegionMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutRegionMargin_value = value_layoutRegionMargin.value;
+        Padding_serializer::write(valueSerializer, value_layoutRegionMargin_value);
     }
-    const auto value_dragBar = value.dragBar;
-    Ark_Int32 value_dragBar_type = INTEROP_RUNTIME_UNDEFINED;
-    value_dragBar_type = runtimeType(value_dragBar);
-    valueSerializer.writeInt8(value_dragBar_type);
-    if ((value_dragBar_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_dragBar_value = value_dragBar.value;
-        valueSerializer.writeBoolean(value_dragBar_value);
+    const auto value_previewAnimationOptions = value.previewAnimationOptions;
+    Ark_Int32 value_previewAnimationOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions);
+    valueSerializer.writeInt8(value_previewAnimationOptions_type);
+    if ((value_previewAnimationOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_previewAnimationOptions_value = value_previewAnimationOptions.value;
+        ContextMenuAnimationOptions_serializer::write(valueSerializer, value_previewAnimationOptions_value);
     }
-    const auto value_maskColor = value.maskColor;
-    Ark_Int32 value_maskColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maskColor_type = runtimeType(value_maskColor);
-    valueSerializer.writeInt8(value_maskColor_type);
-    if ((value_maskColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maskColor_value = value_maskColor.value;
-        Ark_Int32 value_maskColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_maskColor_value_type = value_maskColor_value.selector;
-        if (value_maskColor_value_type == 0) {
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_maskColor_value_0 = value_maskColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_maskColor_value_0));
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_maskColor_value_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_maskColor_value_1 = value_maskColor_value.value1;
-            valueSerializer.writeNumber(value_maskColor_value_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-        else if (value_maskColor_value_type == 2) {
+        else if (value_backgroundColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_maskColor_value_2 = value_maskColor_value.value2;
-            valueSerializer.writeString(value_maskColor_value_2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
         }
-        else if (value_maskColor_value_type == 3) {
+        else if (value_backgroundColor_value_type == 3) {
             valueSerializer.writeInt8(3);
-            const auto value_maskColor_value_3 = value_maskColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_maskColor_value_3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
-    const auto value_detents = value.detents;
-    Ark_Int32 value_detents_type = INTEROP_RUNTIME_UNDEFINED;
-    value_detents_type = runtimeType(value_detents);
-    valueSerializer.writeInt8(value_detents_type);
-    if ((value_detents_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_detents_value = value_detents.value;
-        const auto value_detents_value_0 = value_detents_value.value0;
-        Ark_Int32 value_detents_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-        value_detents_value_0_type = value_detents_value_0.selector;
-        if (value_detents_value_0_type == 0) {
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
+    }
+    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
+    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
+    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
+    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
+        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
+    }
+    const auto value_backgroundEffect = value.backgroundEffect;
+    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
+    valueSerializer.writeInt8(value_backgroundEffect_type);
+    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundEffect_value = value_backgroundEffect.value;
+        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
+    }
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    }
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHoverMode_value = value_enableHoverMode.value;
+        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    }
+    const auto value_outlineColor = value.outlineColor;
+    Ark_Int32 value_outlineColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_outlineColor_type = runtimeType(value_outlineColor);
+    valueSerializer.writeInt8(value_outlineColor_type);
+    if ((value_outlineColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_outlineColor_value = value_outlineColor.value;
+        Ark_Int32 value_outlineColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_outlineColor_value_type = value_outlineColor_value.selector;
+        if ((value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_detents_value_0_0 = value_detents_value_0.value0;
-            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_0_0));
-        }
-        else if ((value_detents_value_0_type == 1) || (value_detents_value_0_type == 1) || (value_detents_value_0_type == 1)) {
-            valueSerializer.writeInt8(1);
-            const auto value_detents_value_0_1 = value_detents_value_0.value1;
-            Ark_Int32 value_detents_value_0_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_detents_value_0_1_type = value_detents_value_0_1.selector;
-            if (value_detents_value_0_1_type == 0) {
+            const auto value_outlineColor_value_0 = value_outlineColor_value.value0;
+            Ark_Int32 value_outlineColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_outlineColor_value_0_type = value_outlineColor_value_0.selector;
+            if (value_outlineColor_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_detents_value_0_1_0 = value_detents_value_0_1.value0;
-                valueSerializer.writeString(value_detents_value_0_1_0);
+                const auto value_outlineColor_value_0_0 = value_outlineColor_value_0.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_outlineColor_value_0_0));
             }
-            else if (value_detents_value_0_1_type == 1) {
+            else if (value_outlineColor_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_detents_value_0_1_1 = value_detents_value_0_1.value1;
-                valueSerializer.writeNumber(value_detents_value_0_1_1);
+                const auto value_outlineColor_value_0_1 = value_outlineColor_value_0.value1;
+                valueSerializer.writeNumber(value_outlineColor_value_0_1);
             }
-            else if (value_detents_value_0_1_type == 2) {
+            else if (value_outlineColor_value_0_type == 2) {
                 valueSerializer.writeInt8(2);
-                const auto value_detents_value_0_1_2 = value_detents_value_0_1.value2;
-                Resource_serializer::write(valueSerializer, value_detents_value_0_1_2);
-            }
-        }
-        const auto value_detents_value_1 = value_detents_value.value1;
-        Ark_Int32 value_detents_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-        value_detents_value_1_type = runtimeType(value_detents_value_1);
-        valueSerializer.writeInt8(value_detents_value_1_type);
-        if ((value_detents_value_1_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-            const auto value_detents_value_1_value = value_detents_value_1.value;
-            Ark_Int32 value_detents_value_1_value_type = INTEROP_RUNTIME_UNDEFINED;
-            value_detents_value_1_value_type = value_detents_value_1_value.selector;
-            if (value_detents_value_1_value_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_detents_value_1_value_0 = value_detents_value_1_value.value0;
-                valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_1_value_0));
+                const auto value_outlineColor_value_0_2 = value_outlineColor_value_0.value2;
+                valueSerializer.writeString(value_outlineColor_value_0_2);
             }
-            else if ((value_detents_value_1_value_type == 1) || (value_detents_value_1_value_type == 1) || (value_detents_value_1_value_type == 1)) {
-                valueSerializer.writeInt8(1);
-                const auto value_detents_value_1_value_1 = value_detents_value_1_value.value1;
-                Ark_Int32 value_detents_value_1_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-                value_detents_value_1_value_1_type = value_detents_value_1_value_1.selector;
-                if (value_detents_value_1_value_1_type == 0) {
-                    valueSerializer.writeInt8(0);
-                    const auto value_detents_value_1_value_1_0 = value_detents_value_1_value_1.value0;
-                    valueSerializer.writeString(value_detents_value_1_value_1_0);
-                }
-                else if (value_detents_value_1_value_1_type == 1) {
-                    valueSerializer.writeInt8(1);
-                    const auto value_detents_value_1_value_1_1 = value_detents_value_1_value_1.value1;
-                    valueSerializer.writeNumber(value_detents_value_1_value_1_1);
-                }
-                else if (value_detents_value_1_value_1_type == 2) {
-                    valueSerializer.writeInt8(2);
-                    const auto value_detents_value_1_value_1_2 = value_detents_value_1_value_1.value2;
-                    Resource_serializer::write(valueSerializer, value_detents_value_1_value_1_2);
-                }
+            else if (value_outlineColor_value_0_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_outlineColor_value_0_3 = value_outlineColor_value_0.value3;
+                Resource_serializer::write(valueSerializer, value_outlineColor_value_0_3);
             }
         }
-        const auto value_detents_value_2 = value_detents_value.value2;
-        Ark_Int32 value_detents_value_2_type = INTEROP_RUNTIME_UNDEFINED;
-        value_detents_value_2_type = runtimeType(value_detents_value_2);
-        valueSerializer.writeInt8(value_detents_value_2_type);
-        if ((value_detents_value_2_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-            const auto value_detents_value_2_value = value_detents_value_2.value;
-            Ark_Int32 value_detents_value_2_value_type = INTEROP_RUNTIME_UNDEFINED;
-            value_detents_value_2_value_type = value_detents_value_2_value.selector;
-            if (value_detents_value_2_value_type == 0) {
+        else if (value_outlineColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_outlineColor_value_1 = value_outlineColor_value.value1;
+            EdgeColors_serializer::write(valueSerializer, value_outlineColor_value_1);
+        }
+    }
+    const auto value_outlineWidth = value.outlineWidth;
+    Ark_Int32 value_outlineWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_outlineWidth_type = runtimeType(value_outlineWidth);
+    valueSerializer.writeInt8(value_outlineWidth_type);
+    if ((value_outlineWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_outlineWidth_value = value_outlineWidth.value;
+        Ark_Int32 value_outlineWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_outlineWidth_value_type = value_outlineWidth_value.selector;
+        if ((value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_outlineWidth_value_0 = value_outlineWidth_value.value0;
+            Ark_Int32 value_outlineWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_outlineWidth_value_0_type = value_outlineWidth_value_0.selector;
+            if (value_outlineWidth_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_detents_value_2_value_0 = value_detents_value_2_value.value0;
-                valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_2_value_0));
+                const auto value_outlineWidth_value_0_0 = value_outlineWidth_value_0.value0;
+                valueSerializer.writeString(value_outlineWidth_value_0_0);
             }
-            else if ((value_detents_value_2_value_type == 1) || (value_detents_value_2_value_type == 1) || (value_detents_value_2_value_type == 1)) {
+            else if (value_outlineWidth_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_detents_value_2_value_1 = value_detents_value_2_value.value1;
-                Ark_Int32 value_detents_value_2_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-                value_detents_value_2_value_1_type = value_detents_value_2_value_1.selector;
-                if (value_detents_value_2_value_1_type == 0) {
-                    valueSerializer.writeInt8(0);
-                    const auto value_detents_value_2_value_1_0 = value_detents_value_2_value_1.value0;
-                    valueSerializer.writeString(value_detents_value_2_value_1_0);
-                }
-                else if (value_detents_value_2_value_1_type == 1) {
-                    valueSerializer.writeInt8(1);
-                    const auto value_detents_value_2_value_1_1 = value_detents_value_2_value_1.value1;
-                    valueSerializer.writeNumber(value_detents_value_2_value_1_1);
-                }
-                else if (value_detents_value_2_value_1_type == 2) {
-                    valueSerializer.writeInt8(2);
-                    const auto value_detents_value_2_value_1_2 = value_detents_value_2_value_1.value2;
-                    Resource_serializer::write(valueSerializer, value_detents_value_2_value_1_2);
-                }
+                const auto value_outlineWidth_value_0_1 = value_outlineWidth_value_0.value1;
+                valueSerializer.writeNumber(value_outlineWidth_value_0_1);
+            }
+            else if (value_outlineWidth_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_outlineWidth_value_0_2 = value_outlineWidth_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_outlineWidth_value_0_2);
             }
         }
-    }
-    const auto value_blurStyle = value.blurStyle;
-    Ark_Int32 value_blurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_blurStyle_type = runtimeType(value_blurStyle);
-    valueSerializer.writeInt8(value_blurStyle_type);
-    if ((value_blurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_blurStyle_value = value_blurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_blurStyle_value));
-    }
-    const auto value_showClose = value.showClose;
-    Ark_Int32 value_showClose_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showClose_type = runtimeType(value_showClose);
-    valueSerializer.writeInt8(value_showClose_type);
-    if ((value_showClose_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showClose_value = value_showClose.value;
-        Ark_Int32 value_showClose_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_showClose_value_type = value_showClose_value.selector;
-        if (value_showClose_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_showClose_value_0 = value_showClose_value.value0;
-            valueSerializer.writeBoolean(value_showClose_value_0);
-        }
-        else if (value_showClose_value_type == 1) {
+        else if (value_outlineWidth_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_showClose_value_1 = value_showClose_value.value1;
-            Resource_serializer::write(valueSerializer, value_showClose_value_1);
+            const auto value_outlineWidth_value_1 = value_outlineWidth_value.value1;
+            EdgeOutlineWidths_serializer::write(valueSerializer, value_outlineWidth_value_1);
         }
     }
-    const auto value_preferType = value.preferType;
-    Ark_Int32 value_preferType_type = INTEROP_RUNTIME_UNDEFINED;
-    value_preferType_type = runtimeType(value_preferType);
-    valueSerializer.writeInt8(value_preferType_type);
-    if ((value_preferType_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_preferType_value = value_preferType.value;
-        valueSerializer.writeInt32(static_cast<Ark_SheetType>(value_preferType_value));
+    const auto value_hapticFeedbackMode = value.hapticFeedbackMode;
+    Ark_Int32 value_hapticFeedbackMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode);
+    valueSerializer.writeInt8(value_hapticFeedbackMode_type);
+    if ((value_hapticFeedbackMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hapticFeedbackMode_value = value_hapticFeedbackMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_HapticFeedbackMode>(value_hapticFeedbackMode_value));
     }
     const auto value_title = value.title;
     Ark_Int32 value_title_type = INTEROP_RUNTIME_UNDEFINED;
@@ -108350,393 +110160,235 @@ inline void SheetOptions_serializer::write(SerializerBase& buffer, Ark_SheetOpti
         if (value_title_value_type == 0) {
             valueSerializer.writeInt8(0);
             const auto value_title_value_0 = value_title_value.value0;
-            SheetTitleOptions_serializer::write(valueSerializer, value_title_value_0);
+            valueSerializer.writeString(value_title_value_0);
         }
         else if (value_title_value_type == 1) {
             valueSerializer.writeInt8(1);
             const auto value_title_value_1 = value_title_value.value1;
-            valueSerializer.writeCallbackResource(value_title_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_title_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_title_value_1.callSync));
+            Resource_serializer::write(valueSerializer, value_title_value_1);
         }
     }
-    const auto value_shouldDismiss = value.shouldDismiss;
-    Ark_Int32 value_shouldDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shouldDismiss_type = runtimeType(value_shouldDismiss);
-    valueSerializer.writeInt8(value_shouldDismiss_type);
-    if ((value_shouldDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shouldDismiss_value = value_shouldDismiss.value;
-        valueSerializer.writeCallbackResource(value_shouldDismiss_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_shouldDismiss_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_shouldDismiss_value.callSync));
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
     }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
+}
+inline Ark_MenuOptions MenuOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_MenuOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offset_buf.value = Position_serializer::read(valueDeserializer);
     }
-    const auto value_onWillSpringBackWhenDismiss = value.onWillSpringBackWhenDismiss;
-    Ark_Int32 value_onWillSpringBackWhenDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillSpringBackWhenDismiss_type = runtimeType(value_onWillSpringBackWhenDismiss);
-    valueSerializer.writeInt8(value_onWillSpringBackWhenDismiss_type);
-    if ((value_onWillSpringBackWhenDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillSpringBackWhenDismiss_value = value_onWillSpringBackWhenDismiss.value;
-        valueSerializer.writeCallbackResource(value_onWillSpringBackWhenDismiss_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillSpringBackWhenDismiss_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillSpringBackWhenDismiss_value.callSync));
+    value.offset = offset_buf;
+    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Placement placement_buf = {};
+    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
     }
-    const auto value_enableOutsideInteractive = value.enableOutsideInteractive;
-    Ark_Int32 value_enableOutsideInteractive_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableOutsideInteractive_type = runtimeType(value_enableOutsideInteractive);
-    valueSerializer.writeInt8(value_enableOutsideInteractive_type);
-    if ((value_enableOutsideInteractive_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableOutsideInteractive_value = value_enableOutsideInteractive.value;
-        valueSerializer.writeBoolean(value_enableOutsideInteractive_value);
+    value.placement = placement_buf;
+    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableArrow_buf = {};
+    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableArrow_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if (value_width_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            valueSerializer.writeString(value_width_value_0);
-        }
-        else if (value_width_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            valueSerializer.writeNumber(value_width_value_1);
-        }
-        else if (value_width_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_width_value_2 = value_width_value.value2;
-            Resource_serializer::write(valueSerializer, value_width_value_2);
+    value.enableArrow = enableArrow_buf;
+    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length arrowOffset_buf = {};
+    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
+        Ark_Length arrowOffset_buf_ = {};
+        arrowOffset_buf_.selector = arrowOffset_buf__selector;
+        if (arrowOffset_buf__selector == 0) {
+            arrowOffset_buf_.selector = 0;
+            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-    }
-    const auto value_borderWidth = value.borderWidth;
-    Ark_Int32 value_borderWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderWidth_type = runtimeType(value_borderWidth);
-    valueSerializer.writeInt8(value_borderWidth_type);
-    if ((value_borderWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderWidth_value = value_borderWidth.value;
-        Ark_Int32 value_borderWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderWidth_value_type = value_borderWidth_value.selector;
-        if ((value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderWidth_value_0 = value_borderWidth_value.value0;
-            Ark_Int32 value_borderWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderWidth_value_0_type = value_borderWidth_value_0.selector;
-            if (value_borderWidth_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderWidth_value_0_0 = value_borderWidth_value_0.value0;
-                valueSerializer.writeString(value_borderWidth_value_0_0);
-            }
-            else if (value_borderWidth_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderWidth_value_0_1 = value_borderWidth_value_0.value1;
-                valueSerializer.writeNumber(value_borderWidth_value_0_1);
-            }
-            else if (value_borderWidth_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderWidth_value_0_2 = value_borderWidth_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderWidth_value_0_2);
-            }
+        else if (arrowOffset_buf__selector == 1) {
+            arrowOffset_buf_.selector = 1;
+            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (value_borderWidth_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderWidth_value_1 = value_borderWidth_value.value1;
-            EdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_1);
+        else if (arrowOffset_buf__selector == 2) {
+            arrowOffset_buf_.selector = 2;
+            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
-        else if (value_borderWidth_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_borderWidth_value_2 = value_borderWidth_value.value2;
-            LocalizedEdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_2);
+        else {
+            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
         }
+        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
     }
-    const auto value_borderColor = value.borderColor;
-    Ark_Int32 value_borderColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderColor_type = runtimeType(value_borderColor);
-    valueSerializer.writeInt8(value_borderColor_type);
-    if ((value_borderColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderColor_value = value_borderColor.value;
-        Ark_Int32 value_borderColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderColor_value_type = value_borderColor_value.selector;
-        if ((value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderColor_value_0 = value_borderColor_value.value0;
-            Ark_Int32 value_borderColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderColor_value_0_type = value_borderColor_value_0.selector;
-            if (value_borderColor_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderColor_value_0_0 = value_borderColor_value_0.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_borderColor_value_0_0));
+    value.arrowOffset = arrowOffset_buf;
+    const auto preview_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_MenuPreviewMode_CustomBuilder preview_buf = {};
+    preview_buf.tag = preview_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((preview_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 preview_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_MenuPreviewMode_CustomBuilder preview_buf_ = {};
+        preview_buf_.selector = preview_buf__selector;
+        if (preview_buf__selector == 0) {
+            preview_buf_.selector = 0;
+            preview_buf_.value0 = static_cast<Ark_MenuPreviewMode>(valueDeserializer.readInt32());
+        }
+        else if (preview_buf__selector == 1) {
+            preview_buf_.selector = 1;
+            preview_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        }
+        else {
+            INTEROP_FATAL("One of the branches for preview_buf_ has to be chosen through deserialisation.");
+        }
+        preview_buf.value = static_cast<Ark_Union_MenuPreviewMode_CustomBuilder>(preview_buf_);
+    }
+    value.preview = preview_buf;
+    const auto previewBorderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BorderRadiusType previewBorderRadius_buf = {};
+    previewBorderRadius_buf.tag = previewBorderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((previewBorderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 previewBorderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_BorderRadiusType previewBorderRadius_buf_ = {};
+        previewBorderRadius_buf_.selector = previewBorderRadius_buf__selector;
+        if (previewBorderRadius_buf__selector == 0) {
+            previewBorderRadius_buf_.selector = 0;
+            const Ark_Int8 previewBorderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length previewBorderRadius_buf__u = {};
+            previewBorderRadius_buf__u.selector = previewBorderRadius_buf__u_selector;
+            if (previewBorderRadius_buf__u_selector == 0) {
+                previewBorderRadius_buf__u.selector = 0;
+                previewBorderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (value_borderColor_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderColor_value_0_1 = value_borderColor_value_0.value1;
-                valueSerializer.writeNumber(value_borderColor_value_0_1);
+            else if (previewBorderRadius_buf__u_selector == 1) {
+                previewBorderRadius_buf__u.selector = 1;
+                previewBorderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (value_borderColor_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderColor_value_0_2 = value_borderColor_value_0.value2;
-                valueSerializer.writeString(value_borderColor_value_0_2);
+            else if (previewBorderRadius_buf__u_selector == 2) {
+                previewBorderRadius_buf__u.selector = 2;
+                previewBorderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
-            else if (value_borderColor_value_0_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_borderColor_value_0_3 = value_borderColor_value_0.value3;
-                Resource_serializer::write(valueSerializer, value_borderColor_value_0_3);
+            else {
+                INTEROP_FATAL("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.");
             }
+            previewBorderRadius_buf_.value0 = static_cast<Ark_Length>(previewBorderRadius_buf__u);
         }
-        else if (value_borderColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderColor_value_1 = value_borderColor_value.value1;
-            EdgeColors_serializer::write(valueSerializer, value_borderColor_value_1);
+        else if (previewBorderRadius_buf__selector == 1) {
+            previewBorderRadius_buf_.selector = 1;
+            previewBorderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
-        else if (value_borderColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_borderColor_value_2 = value_borderColor_value.value2;
-            LocalizedEdgeColors_serializer::write(valueSerializer, value_borderColor_value_2);
+        else if (previewBorderRadius_buf__selector == 2) {
+            previewBorderRadius_buf_.selector = 2;
+            previewBorderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
         }
+        else {
+            INTEROP_FATAL("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.");
+        }
+        previewBorderRadius_buf.value = static_cast<Ark_BorderRadiusType>(previewBorderRadius_buf_);
     }
-    const auto value_borderStyle = value.borderStyle;
-    Ark_Int32 value_borderStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderStyle_type = runtimeType(value_borderStyle);
-    valueSerializer.writeInt8(value_borderStyle_type);
-    if ((value_borderStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderStyle_value = value_borderStyle.value;
-        Ark_Int32 value_borderStyle_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderStyle_value_type = value_borderStyle_value.selector;
-        if (value_borderStyle_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderStyle_value_0 = value_borderStyle_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_BorderStyle>(value_borderStyle_value_0));
+    value.previewBorderRadius = previewBorderRadius_buf;
+    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf = {};
+    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf_ = {};
+        borderRadius_buf_.selector = borderRadius_buf__selector;
+        if (borderRadius_buf__selector == 0) {
+            borderRadius_buf_.selector = 0;
+            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length borderRadius_buf__u = {};
+            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
+            if (borderRadius_buf__u_selector == 0) {
+                borderRadius_buf__u.selector = 0;
+                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderRadius_buf__u_selector == 1) {
+                borderRadius_buf__u.selector = 1;
+                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderRadius_buf__u_selector == 2) {
+                borderRadius_buf__u.selector = 2;
+                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
+            }
+            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
         }
-        else if (value_borderStyle_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderStyle_value_1 = value_borderStyle_value.value1;
-            EdgeStyles_serializer::write(valueSerializer, value_borderStyle_value_1);
+        else if (borderRadius_buf__selector == 1) {
+            borderRadius_buf_.selector = 1;
+            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
-    }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+        else if (borderRadius_buf__selector == 2) {
+            borderRadius_buf_.selector = 2;
+            borderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
         }
-        else if (value_shadow_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+        else {
+            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
         }
+        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses>(borderRadius_buf_);
     }
-    const auto value_onHeightDidChange = value.onHeightDidChange;
-    Ark_Int32 value_onHeightDidChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onHeightDidChange_type = runtimeType(value_onHeightDidChange);
-    valueSerializer.writeInt8(value_onHeightDidChange_type);
-    if ((value_onHeightDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onHeightDidChange_value = value_onHeightDidChange.value;
-        valueSerializer.writeCallbackResource(value_onHeightDidChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHeightDidChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHeightDidChange_value.callSync));
-    }
-    const auto value_mode = value.mode;
-    Ark_Int32 value_mode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_mode_type = runtimeType(value_mode);
-    valueSerializer.writeInt8(value_mode_type);
-    if ((value_mode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_mode_value = value_mode.value;
-        valueSerializer.writeInt32(static_cast<Ark_SheetMode>(value_mode_value));
-    }
-    const auto value_scrollSizeMode = value.scrollSizeMode;
-    Ark_Int32 value_scrollSizeMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_scrollSizeMode_type = runtimeType(value_scrollSizeMode);
-    valueSerializer.writeInt8(value_scrollSizeMode_type);
-    if ((value_scrollSizeMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_scrollSizeMode_value = value_scrollSizeMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_ScrollSizeMode>(value_scrollSizeMode_value));
-    }
-    const auto value_onDetentsDidChange = value.onDetentsDidChange;
-    Ark_Int32 value_onDetentsDidChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDetentsDidChange_type = runtimeType(value_onDetentsDidChange);
-    valueSerializer.writeInt8(value_onDetentsDidChange_type);
-    if ((value_onDetentsDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDetentsDidChange_value = value_onDetentsDidChange.value;
-        valueSerializer.writeCallbackResource(value_onDetentsDidChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDetentsDidChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDetentsDidChange_value.callSync));
-    }
-    const auto value_onWidthDidChange = value.onWidthDidChange;
-    Ark_Int32 value_onWidthDidChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWidthDidChange_type = runtimeType(value_onWidthDidChange);
-    valueSerializer.writeInt8(value_onWidthDidChange_type);
-    if ((value_onWidthDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWidthDidChange_value = value_onWidthDidChange.value;
-        valueSerializer.writeCallbackResource(value_onWidthDidChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWidthDidChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWidthDidChange_value.callSync));
-    }
-    const auto value_onTypeDidChange = value.onTypeDidChange;
-    Ark_Int32 value_onTypeDidChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onTypeDidChange_type = runtimeType(value_onTypeDidChange);
-    valueSerializer.writeInt8(value_onTypeDidChange_type);
-    if ((value_onTypeDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onTypeDidChange_value = value_onTypeDidChange.value;
-        valueSerializer.writeCallbackResource(value_onTypeDidChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onTypeDidChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onTypeDidChange_value.callSync));
-    }
-    const auto value_uiContext = value.uiContext;
-    Ark_Int32 value_uiContext_type = INTEROP_RUNTIME_UNDEFINED;
-    value_uiContext_type = runtimeType(value_uiContext);
-    valueSerializer.writeInt8(value_uiContext_type);
-    if ((value_uiContext_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_uiContext_value = value_uiContext.value;
-        UIContext_serializer::write(valueSerializer, value_uiContext_value);
-    }
-    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
-    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
-    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
-    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_SheetKeyboardAvoidMode>(value_keyboardAvoidMode_value));
-    }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHoverMode_value = value_enableHoverMode.value;
-        valueSerializer.writeBoolean(value_enableHoverMode_value);
-    }
-    const auto value_hoverModeArea = value.hoverModeArea;
-    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
-    valueSerializer.writeInt8(value_hoverModeArea_type);
-    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hoverModeArea_value = value_hoverModeArea.value;
-        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
-    }
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
-    }
-    const auto value_effectEdge = value.effectEdge;
-    Ark_Int32 value_effectEdge_type = INTEROP_RUNTIME_UNDEFINED;
-    value_effectEdge_type = runtimeType(value_effectEdge);
-    valueSerializer.writeInt8(value_effectEdge_type);
-    if ((value_effectEdge_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_effectEdge_value = value_effectEdge.value;
-        valueSerializer.writeNumber(value_effectEdge_value);
+    value.borderRadius = borderRadius_buf;
+    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onAppear_buf = {};
+    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    const auto value_radius = value.radius;
-    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_radius_type = runtimeType(value_radius);
-    valueSerializer.writeInt8(value_radius_type);
-    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_radius_value = value_radius.value;
-        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_radius_value_type = value_radius_value.selector;
-        if (value_radius_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_radius_value_0 = value_radius_value.value0;
-            LengthMetrics_serializer::write(valueSerializer, value_radius_value_0);
-        }
-        else if (value_radius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_radius_value_1 = value_radius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_radius_value_1);
-        }
-        else if (value_radius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_radius_value_2 = value_radius_value.value2;
-            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_radius_value_2);
-        }
+    value.onAppear = onAppear_buf;
+    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDisappear_buf = {};
+    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    const auto value_detentSelection = value.detentSelection;
-    Ark_Int32 value_detentSelection_type = INTEROP_RUNTIME_UNDEFINED;
-    value_detentSelection_type = runtimeType(value_detentSelection);
-    valueSerializer.writeInt8(value_detentSelection_type);
-    if ((value_detentSelection_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_detentSelection_value = value_detentSelection.value;
-        Ark_Int32 value_detentSelection_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_detentSelection_value_type = value_detentSelection_value.selector;
-        if (value_detentSelection_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_detentSelection_value_0 = value_detentSelection_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detentSelection_value_0));
-        }
-        else if ((value_detentSelection_value_type == 1) || (value_detentSelection_value_type == 1) || (value_detentSelection_value_type == 1)) {
-            valueSerializer.writeInt8(1);
-            const auto value_detentSelection_value_1 = value_detentSelection_value.value1;
-            Ark_Int32 value_detentSelection_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_detentSelection_value_1_type = value_detentSelection_value_1.selector;
-            if (value_detentSelection_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_detentSelection_value_1_0 = value_detentSelection_value_1.value0;
-                valueSerializer.writeString(value_detentSelection_value_1_0);
-            }
-            else if (value_detentSelection_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_detentSelection_value_1_1 = value_detentSelection_value_1.value1;
-                valueSerializer.writeNumber(value_detentSelection_value_1_1);
-            }
-            else if (value_detentSelection_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_detentSelection_value_1_2 = value_detentSelection_value_1.value2;
-                Resource_serializer::write(valueSerializer, value_detentSelection_value_1_2);
-            }
-        }
+    value.onDisappear = onDisappear_buf;
+    const auto aboutToAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void aboutToAppear_buf = {};
+    aboutToAppear_buf.tag = aboutToAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((aboutToAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        aboutToAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
+    value.aboutToAppear = aboutToAppear_buf;
+    const auto aboutToDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void aboutToDisappear_buf = {};
+    aboutToDisappear_buf.tag = aboutToDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((aboutToDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        aboutToDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    const auto value_placement = value.placement;
-    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placement_type = runtimeType(value_placement);
-    valueSerializer.writeInt8(value_placement_type);
-    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placement_value = value_placement.value;
-        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
+    value.aboutToDisappear = aboutToDisappear_buf;
+    const auto layoutRegionMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Padding layoutRegionMargin_buf = {};
+    layoutRegionMargin_buf.tag = layoutRegionMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutRegionMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        layoutRegionMargin_buf.value = Padding_serializer::read(valueDeserializer);
     }
-    const auto value_placementOnTarget = value.placementOnTarget;
-    Ark_Int32 value_placementOnTarget_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placementOnTarget_type = runtimeType(value_placementOnTarget);
-    valueSerializer.writeInt8(value_placementOnTarget_type);
-    if ((value_placementOnTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placementOnTarget_value = value_placementOnTarget.value;
-        valueSerializer.writeBoolean(value_placementOnTarget_value);
+    value.layoutRegionMargin = layoutRegionMargin_buf;
+    const auto previewAnimationOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ContextMenuAnimationOptions previewAnimationOptions_buf = {};
+    previewAnimationOptions_buf.tag = previewAnimationOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((previewAnimationOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        previewAnimationOptions_buf.value = ContextMenuAnimationOptions_serializer::read(valueDeserializer);
     }
-}
-inline Ark_SheetOptions SheetOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_SheetOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
+    value.previewAnimationOptions = previewAnimationOptions_buf;
     const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_ResourceColor backgroundColor_buf = {};
     backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -108767,1190 +110419,1044 @@ inline Ark_SheetOptions SheetOptions_serializer::read(DeserializerBase& buffer)
         backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
     value.backgroundColor = backgroundColor_buf;
-    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onAppear_buf = {};
-    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    value.onAppear = onAppear_buf;
-    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDisappear_buf = {};
-    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
+    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
     }
-    value.onDisappear = onDisappear_buf;
-    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillAppear_buf = {};
-    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
+    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
+    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
     }
-    value.onWillAppear = onWillAppear_buf;
-    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillDisappear_buf = {};
-    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundEffect = backgroundEffect_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
     }
-    value.onWillDisappear = onWillDisappear_buf;
-    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_SheetSize_Length height_buf = {};
-    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.transition = transition_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 height_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_SheetSize_Length height_buf_ = {};
-        height_buf_.selector = height_buf__selector;
-        if (height_buf__selector == 0) {
-            height_buf_.selector = 0;
-            height_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
-        }
-        else if (height_buf__selector == 1) {
-            height_buf_.selector = 1;
-            const Ark_Int8 height_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length height_buf__u = {};
-            height_buf__u.selector = height_buf__u_selector;
-            if (height_buf__u_selector == 0) {
-                height_buf__u.selector = 0;
-                height_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+    }
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto outlineColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceColor_EdgeColors outlineColor_buf = {};
+    outlineColor_buf.tag = outlineColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((outlineColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 outlineColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceColor_EdgeColors outlineColor_buf_ = {};
+        outlineColor_buf_.selector = outlineColor_buf__selector;
+        if (outlineColor_buf__selector == 0) {
+            outlineColor_buf_.selector = 0;
+            const Ark_Int8 outlineColor_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor outlineColor_buf__u = {};
+            outlineColor_buf__u.selector = outlineColor_buf__u_selector;
+            if (outlineColor_buf__u_selector == 0) {
+                outlineColor_buf__u.selector = 0;
+                outlineColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
             }
-            else if (height_buf__u_selector == 1) {
-                height_buf__u.selector = 1;
-                height_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (outlineColor_buf__u_selector == 1) {
+                outlineColor_buf__u.selector = 1;
+                outlineColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (height_buf__u_selector == 2) {
-                height_buf__u.selector = 2;
-                height_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (outlineColor_buf__u_selector == 2) {
+                outlineColor_buf__u.selector = 2;
+                outlineColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (outlineColor_buf__u_selector == 3) {
+                outlineColor_buf__u.selector = 3;
+                outlineColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for height_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.");
             }
-            height_buf_.value1 = static_cast<Ark_Length>(height_buf__u);
+            outlineColor_buf_.value0 = static_cast<Ark_ResourceColor>(outlineColor_buf__u);
+        }
+        else if (outlineColor_buf__selector == 1) {
+            outlineColor_buf_.selector = 1;
+            outlineColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for height_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.");
         }
-        height_buf.value = static_cast<Ark_Union_SheetSize_Length>(height_buf_);
+        outlineColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(outlineColor_buf_);
     }
-    value.height = height_buf;
-    const auto dragBar_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean dragBar_buf = {};
-    dragBar_buf.tag = dragBar_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((dragBar_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        dragBar_buf.value = valueDeserializer.readBoolean();
-    }
-    value.dragBar = dragBar_buf;
-    const auto maskColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor maskColor_buf = {};
-    maskColor_buf.tag = maskColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maskColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 maskColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor maskColor_buf_ = {};
-        maskColor_buf_.selector = maskColor_buf__selector;
-        if (maskColor_buf__selector == 0) {
-            maskColor_buf_.selector = 0;
-            maskColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (maskColor_buf__selector == 1) {
-            maskColor_buf_.selector = 1;
-            maskColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (maskColor_buf__selector == 2) {
-            maskColor_buf_.selector = 2;
-            maskColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (maskColor_buf__selector == 3) {
-            maskColor_buf_.selector = 3;
-            maskColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for maskColor_buf_ has to be chosen through deserialisation.");
-        }
-        maskColor_buf.value = static_cast<Ark_ResourceColor>(maskColor_buf_);
-    }
-    value.maskColor = maskColor_buf;
-    const auto detents_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TripleLengthDetents detents_buf = {};
-    detents_buf.tag = detents_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((detents_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.outlineColor = outlineColor_buf;
+    const auto outlineWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth_buf = {};
+    outlineWidth_buf.tag = outlineWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((outlineWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        Ark_TripleLengthDetents detents_buf_ = {};
-        const Ark_Int8 detents_buf__value0_buf_selector = valueDeserializer.readInt8();
-        Ark_Union_SheetSize_Length detents_buf__value0_buf = {};
-        detents_buf__value0_buf.selector = detents_buf__value0_buf_selector;
-        if (detents_buf__value0_buf_selector == 0) {
-            detents_buf__value0_buf.selector = 0;
-            detents_buf__value0_buf.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
-        }
-        else if (detents_buf__value0_buf_selector == 1) {
-            detents_buf__value0_buf.selector = 1;
-            const Ark_Int8 detents_buf__value0_buf_u_selector = valueDeserializer.readInt8();
-            Ark_Length detents_buf__value0_buf_u = {};
-            detents_buf__value0_buf_u.selector = detents_buf__value0_buf_u_selector;
-            if (detents_buf__value0_buf_u_selector == 0) {
-                detents_buf__value0_buf_u.selector = 0;
-                detents_buf__value0_buf_u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (detents_buf__value0_buf_u_selector == 1) {
-                detents_buf__value0_buf_u.selector = 1;
-                detents_buf__value0_buf_u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (detents_buf__value0_buf_u_selector == 2) {
-                detents_buf__value0_buf_u.selector = 2;
-                detents_buf__value0_buf_u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for detents_buf__value0_buf_u has to be chosen through deserialisation.");
-            }
-            detents_buf__value0_buf.value1 = static_cast<Ark_Length>(detents_buf__value0_buf_u);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for detents_buf__value0_buf has to be chosen through deserialisation.");
-        }
-        detents_buf_.value0 = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value0_buf);
-        const auto detents_buf__value1_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-        Opt_Union_SheetSize_Length detents_buf__value1_buf = {};
-        detents_buf__value1_buf.tag = detents_buf__value1_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((detents_buf__value1_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            const Ark_Int8 detents_buf__value1_buf__selector = valueDeserializer.readInt8();
-            Ark_Union_SheetSize_Length detents_buf__value1_buf_ = {};
-            detents_buf__value1_buf_.selector = detents_buf__value1_buf__selector;
-            if (detents_buf__value1_buf__selector == 0) {
-                detents_buf__value1_buf_.selector = 0;
-                detents_buf__value1_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
-            }
-            else if (detents_buf__value1_buf__selector == 1) {
-                detents_buf__value1_buf_.selector = 1;
-                const Ark_Int8 detents_buf__value1_buf__u_selector = valueDeserializer.readInt8();
-                Ark_Length detents_buf__value1_buf__u = {};
-                detents_buf__value1_buf__u.selector = detents_buf__value1_buf__u_selector;
-                if (detents_buf__value1_buf__u_selector == 0) {
-                    detents_buf__value1_buf__u.selector = 0;
-                    detents_buf__value1_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-                }
-                else if (detents_buf__value1_buf__u_selector == 1) {
-                    detents_buf__value1_buf__u.selector = 1;
-                    detents_buf__value1_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-                }
-                else if (detents_buf__value1_buf__u_selector == 2) {
-                    detents_buf__value1_buf__u.selector = 2;
-                    detents_buf__value1_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-                }
-                else {
-                    INTEROP_FATAL("One of the branches for detents_buf__value1_buf__u has to be chosen through deserialisation.");
-                }
-                detents_buf__value1_buf_.value1 = static_cast<Ark_Length>(detents_buf__value1_buf__u);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for detents_buf__value1_buf_ has to be chosen through deserialisation.");
+        const Ark_Int8 outlineWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_EdgeOutlineWidths outlineWidth_buf_ = {};
+        outlineWidth_buf_.selector = outlineWidth_buf__selector;
+        if (outlineWidth_buf__selector == 0) {
+            outlineWidth_buf_.selector = 0;
+            const Ark_Int8 outlineWidth_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension outlineWidth_buf__u = {};
+            outlineWidth_buf__u.selector = outlineWidth_buf__u_selector;
+            if (outlineWidth_buf__u_selector == 0) {
+                outlineWidth_buf__u.selector = 0;
+                outlineWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            detents_buf__value1_buf.value = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value1_buf_);
-        }
-        detents_buf_.value1 = detents_buf__value1_buf;
-        const auto detents_buf__value2_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-        Opt_Union_SheetSize_Length detents_buf__value2_buf = {};
-        detents_buf__value2_buf.tag = detents_buf__value2_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((detents_buf__value2_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            const Ark_Int8 detents_buf__value2_buf__selector = valueDeserializer.readInt8();
-            Ark_Union_SheetSize_Length detents_buf__value2_buf_ = {};
-            detents_buf__value2_buf_.selector = detents_buf__value2_buf__selector;
-            if (detents_buf__value2_buf__selector == 0) {
-                detents_buf__value2_buf_.selector = 0;
-                detents_buf__value2_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
+            else if (outlineWidth_buf__u_selector == 1) {
+                outlineWidth_buf__u.selector = 1;
+                outlineWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (detents_buf__value2_buf__selector == 1) {
-                detents_buf__value2_buf_.selector = 1;
-                const Ark_Int8 detents_buf__value2_buf__u_selector = valueDeserializer.readInt8();
-                Ark_Length detents_buf__value2_buf__u = {};
-                detents_buf__value2_buf__u.selector = detents_buf__value2_buf__u_selector;
-                if (detents_buf__value2_buf__u_selector == 0) {
-                    detents_buf__value2_buf__u.selector = 0;
-                    detents_buf__value2_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-                }
-                else if (detents_buf__value2_buf__u_selector == 1) {
-                    detents_buf__value2_buf__u.selector = 1;
-                    detents_buf__value2_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-                }
-                else if (detents_buf__value2_buf__u_selector == 2) {
-                    detents_buf__value2_buf__u.selector = 2;
-                    detents_buf__value2_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-                }
-                else {
-                    INTEROP_FATAL("One of the branches for detents_buf__value2_buf__u has to be chosen through deserialisation.");
-                }
-                detents_buf__value2_buf_.value1 = static_cast<Ark_Length>(detents_buf__value2_buf__u);
+            else if (outlineWidth_buf__u_selector == 2) {
+                outlineWidth_buf__u.selector = 2;
+                outlineWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for detents_buf__value2_buf_ has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.");
             }
-            detents_buf__value2_buf.value = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value2_buf_);
-        }
-        detents_buf_.value2 = detents_buf__value2_buf;
-        detents_buf.value = detents_buf_;
-    }
-    value.detents = detents_buf;
-    const auto blurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle blurStyle_buf = {};
-    blurStyle_buf.tag = blurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((blurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        blurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
-    }
-    value.blurStyle = blurStyle_buf;
-    const auto showClose_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_Resource showClose_buf = {};
-    showClose_buf.tag = showClose_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showClose_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 showClose_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_Resource showClose_buf_ = {};
-        showClose_buf_.selector = showClose_buf__selector;
-        if (showClose_buf__selector == 0) {
-            showClose_buf_.selector = 0;
-            showClose_buf_.value0 = valueDeserializer.readBoolean();
+            outlineWidth_buf_.value0 = static_cast<Ark_Dimension>(outlineWidth_buf__u);
         }
-        else if (showClose_buf__selector == 1) {
-            showClose_buf_.selector = 1;
-            showClose_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (outlineWidth_buf__selector == 1) {
+            outlineWidth_buf_.selector = 1;
+            outlineWidth_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for showClose_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.");
         }
-        showClose_buf.value = static_cast<Ark_Union_Boolean_Resource>(showClose_buf_);
+        outlineWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(outlineWidth_buf_);
     }
-    value.showClose = showClose_buf;
-    const auto preferType_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SheetType preferType_buf = {};
-    preferType_buf.tag = preferType_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((preferType_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.outlineWidth = outlineWidth_buf;
+    const auto hapticFeedbackMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HapticFeedbackMode hapticFeedbackMode_buf = {};
+    hapticFeedbackMode_buf.tag = hapticFeedbackMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hapticFeedbackMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        preferType_buf.value = static_cast<Ark_SheetType>(valueDeserializer.readInt32());
+        hapticFeedbackMode_buf.value = static_cast<Ark_HapticFeedbackMode>(valueDeserializer.readInt32());
     }
-    value.preferType = preferType_buf;
+    value.hapticFeedbackMode = hapticFeedbackMode_buf;
     const auto title_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_SheetTitleOptions_CustomBuilder title_buf = {};
+    Opt_ResourceStr title_buf = {};
     title_buf.tag = title_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((title_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
         const Ark_Int8 title_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_SheetTitleOptions_CustomBuilder title_buf_ = {};
+        Ark_ResourceStr title_buf_ = {};
         title_buf_.selector = title_buf__selector;
         if (title_buf__selector == 0) {
             title_buf_.selector = 0;
-            title_buf_.value0 = SheetTitleOptions_serializer::read(valueDeserializer);
+            title_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
         else if (title_buf__selector == 1) {
             title_buf_.selector = 1;
-            title_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+            title_buf_.value1 = Resource_serializer::read(valueDeserializer);
         }
         else {
             INTEROP_FATAL("One of the branches for title_buf_ has to be chosen through deserialisation.");
         }
-        title_buf.value = static_cast<Ark_Union_SheetTitleOptions_CustomBuilder>(title_buf_);
+        title_buf.value = static_cast<Ark_ResourceStr>(title_buf_);
     }
     value.title = title_buf;
-    const auto shouldDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_SheetDismiss_Void shouldDismiss_buf = {};
-    shouldDismiss_buf.tag = shouldDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shouldDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        shouldDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_SheetDismiss sheetDismiss)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SheetDismiss_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_SheetDismiss sheetDismiss)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SheetDismiss_Void))))};
-    }
-    value.shouldDismiss = shouldDismiss_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_DismissSheetAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissSheetAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissSheetAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissSheetAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissSheetAction_Void))))};
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
     }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto onWillSpringBackWhenDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_SpringBackAction_Void onWillSpringBackWhenDismiss_buf = {};
-    onWillSpringBackWhenDismiss_buf.tag = onWillSpringBackWhenDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillSpringBackWhenDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWillSpringBackWhenDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_SpringBackAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SpringBackAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_SpringBackAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SpringBackAction_Void))))};
+    value.showInSubWindow = showInSubWindow_buf;
+    return value;
+}
+inline void MenuOutlineOptions_serializer::write(SerializerBase& buffer, Ark_MenuOutlineOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if ((value_width_value_type == 0) || (value_width_value_type == 0) || (value_width_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_width_value_0 = value_width_value.value0;
+            Ark_Int32 value_width_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_width_value_0_type = value_width_value_0.selector;
+            if (value_width_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_width_value_0_0 = value_width_value_0.value0;
+                valueSerializer.writeString(value_width_value_0_0);
+            }
+            else if (value_width_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_width_value_0_1 = value_width_value_0.value1;
+                valueSerializer.writeNumber(value_width_value_0_1);
+            }
+            else if (value_width_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_width_value_0_2 = value_width_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_width_value_0_2);
+            }
+        }
+        else if (value_width_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_width_value_1 = value_width_value.value1;
+            EdgeOutlineWidths_serializer::write(valueSerializer, value_width_value_1);
+        }
     }
-    value.onWillSpringBackWhenDismiss = onWillSpringBackWhenDismiss_buf;
-    const auto enableOutsideInteractive_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableOutsideInteractive_buf = {};
-    enableOutsideInteractive_buf.tag = enableOutsideInteractive_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableOutsideInteractive_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableOutsideInteractive_buf.value = valueDeserializer.readBoolean();
+    const auto value_color = value.color;
+    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
+    value_color_type = runtimeType(value_color);
+    valueSerializer.writeInt8(value_color_type);
+    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_color_value = value_color.value;
+        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_color_value_type = value_color_value.selector;
+        if ((value_color_value_type == 0) || (value_color_value_type == 0) || (value_color_value_type == 0) || (value_color_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_color_value_0 = value_color_value.value0;
+            Ark_Int32 value_color_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_color_value_0_type = value_color_value_0.selector;
+            if (value_color_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_color_value_0_0 = value_color_value_0.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0_0));
+            }
+            else if (value_color_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_color_value_0_1 = value_color_value_0.value1;
+                valueSerializer.writeNumber(value_color_value_0_1);
+            }
+            else if (value_color_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_color_value_0_2 = value_color_value_0.value2;
+                valueSerializer.writeString(value_color_value_0_2);
+            }
+            else if (value_color_value_0_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_color_value_0_3 = value_color_value_0.value3;
+                Resource_serializer::write(valueSerializer, value_color_value_0_3);
+            }
+        }
+        else if (value_color_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_color_value_1 = value_color_value.value1;
+            EdgeColors_serializer::write(valueSerializer, value_color_value_1);
+        }
     }
-    value.enableOutsideInteractive = enableOutsideInteractive_buf;
+}
+inline Ark_MenuOutlineOptions MenuOutlineOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_MenuOutlineOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
     const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension width_buf = {};
+    Opt_Union_Dimension_EdgeOutlineWidths width_buf = {};
     width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
         const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension width_buf_ = {};
+        Ark_Union_Dimension_EdgeOutlineWidths width_buf_ = {};
         width_buf_.selector = width_buf__selector;
         if (width_buf__selector == 0) {
             width_buf_.selector = 0;
-            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (width_buf__selector == 2) {
-            width_buf_.selector = 2;
-            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
-        }
-        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
-    }
-    value.width = width_buf;
-    const auto borderWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_EdgeWidths_LocalizedEdgeWidths borderWidth_buf = {};
-    borderWidth_buf.tag = borderWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_EdgeWidths_LocalizedEdgeWidths borderWidth_buf_ = {};
-        borderWidth_buf_.selector = borderWidth_buf__selector;
-        if (borderWidth_buf__selector == 0) {
-            borderWidth_buf_.selector = 0;
-            const Ark_Int8 borderWidth_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension borderWidth_buf__u = {};
-            borderWidth_buf__u.selector = borderWidth_buf__u_selector;
-            if (borderWidth_buf__u_selector == 0) {
-                borderWidth_buf__u.selector = 0;
-                borderWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            const Ark_Int8 width_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension width_buf__u = {};
+            width_buf__u.selector = width_buf__u_selector;
+            if (width_buf__u_selector == 0) {
+                width_buf__u.selector = 0;
+                width_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (borderWidth_buf__u_selector == 1) {
-                borderWidth_buf__u.selector = 1;
-                borderWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (width_buf__u_selector == 1) {
+                width_buf__u.selector = 1;
+                width_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (borderWidth_buf__u_selector == 2) {
-                borderWidth_buf__u.selector = 2;
-                borderWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (width_buf__u_selector == 2) {
+                width_buf__u.selector = 2;
+                width_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for width_buf__u has to be chosen through deserialisation.");
             }
-            borderWidth_buf_.value0 = static_cast<Ark_Dimension>(borderWidth_buf__u);
-        }
-        else if (borderWidth_buf__selector == 1) {
-            borderWidth_buf_.selector = 1;
-            borderWidth_buf_.value1 = EdgeWidths_serializer::read(valueDeserializer);
+            width_buf_.value0 = static_cast<Ark_Dimension>(width_buf__u);
         }
-        else if (borderWidth_buf__selector == 2) {
-            borderWidth_buf_.selector = 2;
-            borderWidth_buf_.value2 = LocalizedEdgeWidths_serializer::read(valueDeserializer);
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            width_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
         }
-        borderWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeWidths_LocalizedEdgeWidths>(borderWidth_buf_);
+        width_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(width_buf_);
     }
-    value.borderWidth = borderWidth_buf;
-    const auto borderColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceColor_EdgeColors_LocalizedEdgeColors borderColor_buf = {};
-    borderColor_buf.tag = borderColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.width = width_buf;
+    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceColor_EdgeColors color_buf = {};
+    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 borderColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceColor_EdgeColors_LocalizedEdgeColors borderColor_buf_ = {};
-        borderColor_buf_.selector = borderColor_buf__selector;
-        if (borderColor_buf__selector == 0) {
-            borderColor_buf_.selector = 0;
-            const Ark_Int8 borderColor_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor borderColor_buf__u = {};
-            borderColor_buf__u.selector = borderColor_buf__u_selector;
-            if (borderColor_buf__u_selector == 0) {
-                borderColor_buf__u.selector = 0;
-                borderColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceColor_EdgeColors color_buf_ = {};
+        color_buf_.selector = color_buf__selector;
+        if (color_buf__selector == 0) {
+            color_buf_.selector = 0;
+            const Ark_Int8 color_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor color_buf__u = {};
+            color_buf__u.selector = color_buf__u_selector;
+            if (color_buf__u_selector == 0) {
+                color_buf__u.selector = 0;
+                color_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
             }
-            else if (borderColor_buf__u_selector == 1) {
-                borderColor_buf__u.selector = 1;
-                borderColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (color_buf__u_selector == 1) {
+                color_buf__u.selector = 1;
+                color_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (borderColor_buf__u_selector == 2) {
-                borderColor_buf__u.selector = 2;
-                borderColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            else if (color_buf__u_selector == 2) {
+                color_buf__u.selector = 2;
+                color_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (borderColor_buf__u_selector == 3) {
-                borderColor_buf__u.selector = 3;
-                borderColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
+            else if (color_buf__u_selector == 3) {
+                color_buf__u.selector = 3;
+                color_buf__u.value3 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for borderColor_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for color_buf__u has to be chosen through deserialisation.");
             }
-            borderColor_buf_.value0 = static_cast<Ark_ResourceColor>(borderColor_buf__u);
-        }
-        else if (borderColor_buf__selector == 1) {
-            borderColor_buf_.selector = 1;
-            borderColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
-        }
-        else if (borderColor_buf__selector == 2) {
-            borderColor_buf_.selector = 2;
-            borderColor_buf_.value2 = LocalizedEdgeColors_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for borderColor_buf_ has to be chosen through deserialisation.");
-        }
-        borderColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors_LocalizedEdgeColors>(borderColor_buf_);
-    }
-    value.borderColor = borderColor_buf;
-    const auto borderStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_BorderStyle_EdgeStyles borderStyle_buf = {};
-    borderStyle_buf.tag = borderStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderStyle_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_BorderStyle_EdgeStyles borderStyle_buf_ = {};
-        borderStyle_buf_.selector = borderStyle_buf__selector;
-        if (borderStyle_buf__selector == 0) {
-            borderStyle_buf_.selector = 0;
-            borderStyle_buf_.value0 = static_cast<Ark_BorderStyle>(valueDeserializer.readInt32());
+            color_buf_.value0 = static_cast<Ark_ResourceColor>(color_buf__u);
         }
-        else if (borderStyle_buf__selector == 1) {
-            borderStyle_buf_.selector = 1;
-            borderStyle_buf_.value1 = EdgeStyles_serializer::read(valueDeserializer);
+        else if (color_buf__selector == 1) {
+            color_buf_.selector = 1;
+            color_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
         }
-        borderStyle_buf.value = static_cast<Ark_Union_BorderStyle_EdgeStyles>(borderStyle_buf_);
+        color_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(color_buf_);
     }
-    value.borderStyle = borderStyle_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
-        }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
-        }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+    value.color = color_buf;
+    return value;
+}
+inline void MouseEvent_serializer::write(SerializerBase& buffer, Ark_MouseEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_MouseEvent MouseEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_MouseEvent>(ptr);
+}
+inline void NativeEmbedInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedInfo value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_id = value.id;
+    Ark_Int32 value_id_type = INTEROP_RUNTIME_UNDEFINED;
+    value_id_type = runtimeType(value_id);
+    valueSerializer.writeInt8(value_id_type);
+    if ((value_id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_id_value = value_id.value;
+        valueSerializer.writeString(value_id_value);
     }
-    value.shadow = shadow_buf;
-    const auto onHeightDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Number_Void onHeightDidChange_buf = {};
-    onHeightDidChange_buf.tag = onHeightDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onHeightDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onHeightDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
+    const auto value_type = value.type;
+    Ark_Int32 value_type_type = INTEROP_RUNTIME_UNDEFINED;
+    value_type_type = runtimeType(value_type);
+    valueSerializer.writeInt8(value_type_type);
+    if ((value_type_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_type_value = value_type.value;
+        valueSerializer.writeString(value_type_value);
     }
-    value.onHeightDidChange = onHeightDidChange_buf;
-    const auto mode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SheetMode mode_buf = {};
-    mode_buf.tag = mode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((mode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        mode_buf.value = static_cast<Ark_SheetMode>(valueDeserializer.readInt32());
+    const auto value_src = value.src;
+    Ark_Int32 value_src_type = INTEROP_RUNTIME_UNDEFINED;
+    value_src_type = runtimeType(value_src);
+    valueSerializer.writeInt8(value_src_type);
+    if ((value_src_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_src_value = value_src.value;
+        valueSerializer.writeString(value_src_value);
     }
-    value.mode = mode_buf;
-    const auto scrollSizeMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ScrollSizeMode scrollSizeMode_buf = {};
-    scrollSizeMode_buf.tag = scrollSizeMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((scrollSizeMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        scrollSizeMode_buf.value = static_cast<Ark_ScrollSizeMode>(valueDeserializer.readInt32());
+    const auto value_position = value.position;
+    Ark_Int32 value_position_type = INTEROP_RUNTIME_UNDEFINED;
+    value_position_type = runtimeType(value_position);
+    valueSerializer.writeInt8(value_position_type);
+    if ((value_position_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_position_value = value_position.value;
+        Position_serializer::write(valueSerializer, value_position_value);
     }
-    value.scrollSizeMode = scrollSizeMode_buf;
-    const auto onDetentsDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Number_Void onDetentsDidChange_buf = {};
-    onDetentsDidChange_buf.tag = onDetentsDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDetentsDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onDetentsDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        valueSerializer.writeInt32(value_width_value);
     }
-    value.onDetentsDidChange = onDetentsDidChange_buf;
-    const auto onWidthDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Number_Void onWidthDidChange_buf = {};
-    onWidthDidChange_buf.tag = onWidthDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWidthDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWidthDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
+    const auto value_height = value.height;
+    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
+    value_height_type = runtimeType(value_height);
+    valueSerializer.writeInt8(value_height_type);
+    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_height_value = value_height.value;
+        valueSerializer.writeInt32(value_height_value);
     }
-    value.onWidthDidChange = onWidthDidChange_buf;
-    const auto onTypeDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_SheetType_Void onTypeDidChange_buf = {};
-    onTypeDidChange_buf.tag = onTypeDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onTypeDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onTypeDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, Ark_SheetType value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SheetType_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, Ark_SheetType value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SheetType_Void))))};
+    const auto value_url = value.url;
+    Ark_Int32 value_url_type = INTEROP_RUNTIME_UNDEFINED;
+    value_url_type = runtimeType(value_url);
+    valueSerializer.writeInt8(value_url_type);
+    if ((value_url_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_url_value = value_url.value;
+        valueSerializer.writeString(value_url_value);
     }
-    value.onTypeDidChange = onTypeDidChange_buf;
-    const auto uiContext_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_UIContext uiContext_buf = {};
-    uiContext_buf.tag = uiContext_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((uiContext_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        uiContext_buf.value = static_cast<Ark_UIContext>(UIContext_serializer::read(valueDeserializer));
+    const auto value_tag = value.tag;
+    Ark_Int32 value_tag_type = INTEROP_RUNTIME_UNDEFINED;
+    value_tag_type = runtimeType(value_tag);
+    valueSerializer.writeInt8(value_tag_type);
+    if ((value_tag_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_tag_value = value_tag.value;
+        valueSerializer.writeString(value_tag_value);
     }
-    value.uiContext = uiContext_buf;
-    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SheetKeyboardAvoidMode keyboardAvoidMode_buf = {};
-    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto value_params = value.params;
+    Ark_Int32 value_params_type = INTEROP_RUNTIME_UNDEFINED;
+    value_params_type = runtimeType(value_params);
+    valueSerializer.writeInt8(value_params_type);
+    if ((value_params_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_params_value = value_params.value;
+        valueSerializer.writeInt32(value_params_value.size);
+        for (int32_t i = 0; i < value_params_value.size; i++) {
+            auto value_params_value_key = value_params_value.keys[i];
+            auto value_params_value_value = value_params_value.values[i];
+            valueSerializer.writeString(value_params_value_key);
+            valueSerializer.writeString(value_params_value_value);
+        }
+    }
+}
+inline Ark_NativeEmbedInfo NativeEmbedInfo_serializer::read(DeserializerBase& buffer)
+{
+    Ark_NativeEmbedInfo value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String id_buf = {};
+    id_buf.tag = id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        keyboardAvoidMode_buf.value = static_cast<Ark_SheetKeyboardAvoidMode>(valueDeserializer.readInt32());
+        id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.keyboardAvoidMode = keyboardAvoidMode_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.id = id_buf;
+    const auto type_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String type_buf = {};
+    type_buf.tag = type_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((type_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+        type_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HoverModeAreaType hoverModeArea_buf = {};
-    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.type = type_buf;
+    const auto src_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String src_buf = {};
+    src_buf.tag = src_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((src_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
+        src_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.hoverModeArea = hoverModeArea_buf;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.src = src_buf;
+    const auto position_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position position_buf = {};
+    position_buf.tag = position_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((position_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
+        position_buf.value = Position_serializer::read(valueDeserializer);
     }
-    value.offset = offset_buf;
-    const auto effectEdge_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number effectEdge_buf = {};
-    effectEdge_buf.tag = effectEdge_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((effectEdge_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.position = position_buf;
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Int32 width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        effectEdge_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        width_buf.value = valueDeserializer.readInt32();
     }
-    value.effectEdge = effectEdge_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.width = width_buf;
+    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Int32 height_buf = {};
+    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            radius_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
-        }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            radius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else if (radius_buf__selector == 2) {
-            radius_buf_.selector = 2;
-            radius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
-        }
-        radius_buf.value = static_cast<Ark_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses>(radius_buf_);
+        height_buf.value = valueDeserializer.readInt32();
     }
-    value.radius = radius_buf;
-    const auto detentSelection_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_SheetSize_Length detentSelection_buf = {};
-    detentSelection_buf.tag = detentSelection_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((detentSelection_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.height = height_buf;
+    const auto url_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String url_buf = {};
+    url_buf.tag = url_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((url_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 detentSelection_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_SheetSize_Length detentSelection_buf_ = {};
-        detentSelection_buf_.selector = detentSelection_buf__selector;
-        if (detentSelection_buf__selector == 0) {
-            detentSelection_buf_.selector = 0;
-            detentSelection_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
-        }
-        else if (detentSelection_buf__selector == 1) {
-            detentSelection_buf_.selector = 1;
-            const Ark_Int8 detentSelection_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length detentSelection_buf__u = {};
-            detentSelection_buf__u.selector = detentSelection_buf__u_selector;
-            if (detentSelection_buf__u_selector == 0) {
-                detentSelection_buf__u.selector = 0;
-                detentSelection_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (detentSelection_buf__u_selector == 1) {
-                detentSelection_buf__u.selector = 1;
-                detentSelection_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (detentSelection_buf__u_selector == 2) {
-                detentSelection_buf__u.selector = 2;
-                detentSelection_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for detentSelection_buf__u has to be chosen through deserialisation.");
-            }
-            detentSelection_buf_.value1 = static_cast<Ark_Length>(detentSelection_buf__u);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for detentSelection_buf_ has to be chosen through deserialisation.");
-        }
-        detentSelection_buf.value = static_cast<Ark_Union_SheetSize_Length>(detentSelection_buf_);
+        url_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.detentSelection = detentSelection_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.url = url_buf;
+    const auto tag_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String tag_buf = {};
+    tag_buf.tag = tag_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((tag_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+        tag_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.showInSubWindow = showInSubWindow_buf;
-    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Placement placement_buf = {};
-    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.tag = tag_buf;
+    const auto params_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Map_String_String params_buf = {};
+    params_buf.tag = params_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((params_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
+        const Ark_Int32 params_buf__size = valueDeserializer.readInt32();
+        Map_String_String params_buf_ = {};
+        valueDeserializer.resizeMap<Map_String_String, Ark_String, Ark_String>(&params_buf_, params_buf__size);
+        for (int params_buf__i = 0; params_buf__i < params_buf__size; params_buf__i++) {
+            const Ark_String params_buf__key = static_cast<Ark_String>(valueDeserializer.readString());
+            const Ark_String params_buf__value = static_cast<Ark_String>(valueDeserializer.readString());
+            params_buf_.keys[params_buf__i] = params_buf__key;
+            params_buf_.values[params_buf__i] = params_buf__value;
+        }
+        params_buf.value = params_buf_;
     }
-    value.placement = placement_buf;
-    const auto placementOnTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean placementOnTarget_buf = {};
-    placementOnTarget_buf.tag = placementOnTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placementOnTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.params = params_buf;
+    return value;
+}
+inline void NavigationMenuOptions_serializer::write(SerializerBase& buffer, Ark_NavigationMenuOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_moreButtonOptions = value.moreButtonOptions;
+    Ark_Int32 value_moreButtonOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_moreButtonOptions_type = runtimeType(value_moreButtonOptions);
+    valueSerializer.writeInt8(value_moreButtonOptions_type);
+    if ((value_moreButtonOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_moreButtonOptions_value = value_moreButtonOptions.value;
+        MoreButtonOptions_serializer::write(valueSerializer, value_moreButtonOptions_value);
+    }
+}
+inline Ark_NavigationMenuOptions NavigationMenuOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_NavigationMenuOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto moreButtonOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_MoreButtonOptions moreButtonOptions_buf = {};
+    moreButtonOptions_buf.tag = moreButtonOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((moreButtonOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        placementOnTarget_buf.value = valueDeserializer.readBoolean();
+        moreButtonOptions_buf.value = MoreButtonOptions_serializer::read(valueDeserializer);
     }
-    value.placementOnTarget = placementOnTarget_buf;
+    value.moreButtonOptions = moreButtonOptions_buf;
     return value;
 }
-inline void SwipeActionOptions_serializer::write(SerializerBase& buffer, Ark_SwipeActionOptions value)
+inline void NavigationToolbarOptions_serializer::write(SerializerBase& buffer, Ark_NavigationToolbarOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_start = value.start;
-    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
-    value_start_type = runtimeType(value_start);
-    valueSerializer.writeInt8(value_start_type);
-    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_start_value = value_start.value;
-        Ark_Int32 value_start_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_start_value_type = value_start_value.selector;
-        if (value_start_value_type == 0) {
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_start_value_0 = value_start_value.value0;
-            valueSerializer.writeCallbackResource(value_start_value_0.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_start_value_0.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_start_value_0.callSync));
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_start_value_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_start_value_1 = value_start_value.value1;
-            SwipeActionItem_serializer::write(valueSerializer, value_start_value_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-    }
-    const auto value_end = value.end;
-    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
-    value_end_type = runtimeType(value_end);
-    valueSerializer.writeInt8(value_end_type);
-    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_end_value = value_end.value;
-        Ark_Int32 value_end_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_end_value_type = value_end_value.selector;
-        if (value_end_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_end_value_0 = value_end_value.value0;
-            valueSerializer.writeCallbackResource(value_end_value_0.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_end_value_0.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_end_value_0.callSync));
+        else if (value_backgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
         }
-        else if (value_end_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_end_value_1 = value_end_value.value1;
-            SwipeActionItem_serializer::write(valueSerializer, value_end_value_1);
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
-    const auto value_edgeEffect = value.edgeEffect;
-    Ark_Int32 value_edgeEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_edgeEffect_type = runtimeType(value_edgeEffect);
-    valueSerializer.writeInt8(value_edgeEffect_type);
-    if ((value_edgeEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_edgeEffect_value = value_edgeEffect.value;
-        valueSerializer.writeInt32(static_cast<Ark_SwipeEdgeEffect>(value_edgeEffect_value));
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
     }
-    const auto value_onOffsetChange = value.onOffsetChange;
-    Ark_Int32 value_onOffsetChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onOffsetChange_type = runtimeType(value_onOffsetChange);
-    valueSerializer.writeInt8(value_onOffsetChange_type);
-    if ((value_onOffsetChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onOffsetChange_value = value_onOffsetChange.value;
-        valueSerializer.writeCallbackResource(value_onOffsetChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onOffsetChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onOffsetChange_value.callSync));
+    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
+    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
+    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
+    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
+        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
+    }
+    const auto value_backgroundEffect = value.backgroundEffect;
+    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
+    valueSerializer.writeInt8(value_backgroundEffect_type);
+    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundEffect_value = value_backgroundEffect.value;
+        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
+    }
+    const auto value_moreButtonOptions = value.moreButtonOptions;
+    Ark_Int32 value_moreButtonOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_moreButtonOptions_type = runtimeType(value_moreButtonOptions);
+    valueSerializer.writeInt8(value_moreButtonOptions_type);
+    if ((value_moreButtonOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_moreButtonOptions_value = value_moreButtonOptions.value;
+        MoreButtonOptions_serializer::write(valueSerializer, value_moreButtonOptions_value);
+    }
+    const auto value_barStyle = value.barStyle;
+    Ark_Int32 value_barStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_barStyle_type = runtimeType(value_barStyle);
+    valueSerializer.writeInt8(value_barStyle_type);
+    if ((value_barStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_barStyle_value = value_barStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BarStyle>(value_barStyle_value));
+    }
+    const auto value_hideItemValue = value.hideItemValue;
+    Ark_Int32 value_hideItemValue_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hideItemValue_type = runtimeType(value_hideItemValue);
+    valueSerializer.writeInt8(value_hideItemValue_type);
+    if ((value_hideItemValue_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hideItemValue_value = value_hideItemValue.value;
+        valueSerializer.writeBoolean(value_hideItemValue_value);
     }
 }
-inline Ark_SwipeActionOptions SwipeActionOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_NavigationToolbarOptions NavigationToolbarOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_SwipeActionOptions value = {};
+    Ark_NavigationToolbarOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_CustomBuilder_SwipeActionItem start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 start_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_CustomBuilder_SwipeActionItem start_buf_ = {};
-        start_buf_.selector = start_buf__selector;
-        if (start_buf__selector == 0) {
-            start_buf_.selector = 0;
-            start_buf_.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
-        }
-        else if (start_buf__selector == 1) {
-            start_buf_.selector = 1;
-            start_buf_.value1 = SwipeActionItem_serializer::read(valueDeserializer);
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else {
-            INTEROP_FATAL("One of the branches for start_buf_ has to be chosen through deserialisation.");
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        start_buf.value = static_cast<Ark_Union_CustomBuilder_SwipeActionItem>(start_buf_);
-    }
-    value.start = start_buf;
-    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_CustomBuilder_SwipeActionItem end_buf = {};
-    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 end_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_CustomBuilder_SwipeActionItem end_buf_ = {};
-        end_buf_.selector = end_buf__selector;
-        if (end_buf__selector == 0) {
-            end_buf_.selector = 0;
-            end_buf_.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (end_buf__selector == 1) {
-            end_buf_.selector = 1;
-            end_buf_.value1 = SwipeActionItem_serializer::read(valueDeserializer);
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for end_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
         }
-        end_buf.value = static_cast<Ark_Union_CustomBuilder_SwipeActionItem>(end_buf_);
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-    value.end = end_buf;
-    const auto edgeEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SwipeEdgeEffect edgeEffect_buf = {};
-    edgeEffect_buf.tag = edgeEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((edgeEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundColor = backgroundColor_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        edgeEffect_buf.value = static_cast<Ark_SwipeEdgeEffect>(valueDeserializer.readInt32());
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    value.edgeEffect = edgeEffect_buf;
-    const auto onOffsetChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Number_Void onOffsetChange_buf = {};
-    onOffsetChange_buf.tag = onOffsetChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onOffsetChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
+    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onOffsetChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number offset)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number offset)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
+        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
     }
-    value.onOffsetChange = onOffsetChange_buf;
+    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
+    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
+    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
+    }
+    value.backgroundEffect = backgroundEffect_buf;
+    const auto moreButtonOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_MoreButtonOptions moreButtonOptions_buf = {};
+    moreButtonOptions_buf.tag = moreButtonOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((moreButtonOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        moreButtonOptions_buf.value = MoreButtonOptions_serializer::read(valueDeserializer);
+    }
+    value.moreButtonOptions = moreButtonOptions_buf;
+    const auto barStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BarStyle barStyle_buf = {};
+    barStyle_buf.tag = barStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((barStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        barStyle_buf.value = static_cast<Ark_BarStyle>(valueDeserializer.readInt32());
+    }
+    value.barStyle = barStyle_buf;
+    const auto hideItemValue_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean hideItemValue_buf = {};
+    hideItemValue_buf.tag = hideItemValue_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hideItemValue_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        hideItemValue_buf.value = valueDeserializer.readBoolean();
+    }
+    value.hideItemValue = hideItemValue_buf;
     return value;
 }
-inline void SwipeGestureEvent_serializer::write(SerializerBase& buffer, Ark_SwipeGestureEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_SwipeGestureEvent SwipeGestureEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_SwipeGestureEvent>(ptr);
-}
-inline void TabBarLabelStyle_serializer::write(SerializerBase& buffer, Ark_TabBarLabelStyle value)
+inline void OutlineOptions_serializer::write(SerializerBase& buffer, Ark_OutlineOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_overflow = value.overflow;
-    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_overflow_type = runtimeType(value_overflow);
-    valueSerializer.writeInt8(value_overflow_type);
-    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_overflow_value = value_overflow.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
-    }
-    const auto value_maxLines = value.maxLines;
-    Ark_Int32 value_maxLines_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maxLines_type = runtimeType(value_maxLines);
-    valueSerializer.writeInt8(value_maxLines_type);
-    if ((value_maxLines_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maxLines_value = value_maxLines.value;
-        valueSerializer.writeNumber(value_maxLines_value);
-    }
-    const auto value_minFontSize = value.minFontSize;
-    Ark_Int32 value_minFontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_minFontSize_type = runtimeType(value_minFontSize);
-    valueSerializer.writeInt8(value_minFontSize_type);
-    if ((value_minFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_minFontSize_value = value_minFontSize.value;
-        Ark_Int32 value_minFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_minFontSize_value_type = value_minFontSize_value.selector;
-        if (value_minFontSize_value_type == 0) {
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if (value_width_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_minFontSize_value_0 = value_minFontSize_value.value0;
-            valueSerializer.writeNumber(value_minFontSize_value_0);
+            const auto value_width_value_0 = value_width_value.value0;
+            EdgeOutlineWidths_serializer::write(valueSerializer, value_width_value_0);
         }
-        else if ((value_minFontSize_value_type == 1) || (value_minFontSize_value_type == 1)) {
+        else if ((value_width_value_type == 1) || (value_width_value_type == 1) || (value_width_value_type == 1)) {
             valueSerializer.writeInt8(1);
-            const auto value_minFontSize_value_1 = value_minFontSize_value.value1;
-            Ark_Int32 value_minFontSize_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_minFontSize_value_1_type = value_minFontSize_value_1.selector;
-            if (value_minFontSize_value_1_type == 0) {
+            const auto value_width_value_1 = value_width_value.value1;
+            Ark_Int32 value_width_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_width_value_1_type = value_width_value_1.selector;
+            if (value_width_value_1_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_minFontSize_value_1_0 = value_minFontSize_value_1.value0;
-                valueSerializer.writeString(value_minFontSize_value_1_0);
+                const auto value_width_value_1_0 = value_width_value_1.value0;
+                valueSerializer.writeString(value_width_value_1_0);
             }
-            else if (value_minFontSize_value_1_type == 1) {
+            else if (value_width_value_1_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_minFontSize_value_1_1 = value_minFontSize_value_1.value1;
-                Resource_serializer::write(valueSerializer, value_minFontSize_value_1_1);
+                const auto value_width_value_1_1 = value_width_value_1.value1;
+                valueSerializer.writeNumber(value_width_value_1_1);
+            }
+            else if (value_width_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_width_value_1_2 = value_width_value_1.value2;
+                Resource_serializer::write(valueSerializer, value_width_value_1_2);
             }
         }
     }
-    const auto value_maxFontSize = value.maxFontSize;
-    Ark_Int32 value_maxFontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maxFontSize_type = runtimeType(value_maxFontSize);
-    valueSerializer.writeInt8(value_maxFontSize_type);
-    if ((value_maxFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maxFontSize_value = value_maxFontSize.value;
-        Ark_Int32 value_maxFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_maxFontSize_value_type = value_maxFontSize_value.selector;
-        if (value_maxFontSize_value_type == 0) {
+    const auto value_color = value.color;
+    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
+    value_color_type = runtimeType(value_color);
+    valueSerializer.writeInt8(value_color_type);
+    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_color_value = value_color.value;
+        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_color_value_type = value_color_value.selector;
+        if (value_color_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_maxFontSize_value_0 = value_maxFontSize_value.value0;
-            valueSerializer.writeNumber(value_maxFontSize_value_0);
+            const auto value_color_value_0 = value_color_value.value0;
+            EdgeColors_serializer::write(valueSerializer, value_color_value_0);
         }
-        else if ((value_maxFontSize_value_type == 1) || (value_maxFontSize_value_type == 1)) {
+        else if ((value_color_value_type == 1) || (value_color_value_type == 1) || (value_color_value_type == 1) || (value_color_value_type == 1)) {
             valueSerializer.writeInt8(1);
-            const auto value_maxFontSize_value_1 = value_maxFontSize_value.value1;
-            Ark_Int32 value_maxFontSize_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value_maxFontSize_value_1_type = value_maxFontSize_value_1.selector;
-            if (value_maxFontSize_value_1_type == 0) {
+            const auto value_color_value_1 = value_color_value.value1;
+            Ark_Int32 value_color_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_color_value_1_type = value_color_value_1.selector;
+            if (value_color_value_1_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_maxFontSize_value_1_0 = value_maxFontSize_value_1.value0;
-                valueSerializer.writeString(value_maxFontSize_value_1_0);
+                const auto value_color_value_1_0 = value_color_value_1.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_1_0));
             }
-            else if (value_maxFontSize_value_1_type == 1) {
+            else if (value_color_value_1_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_maxFontSize_value_1_1 = value_maxFontSize_value_1.value1;
-                Resource_serializer::write(valueSerializer, value_maxFontSize_value_1_1);
+                const auto value_color_value_1_1 = value_color_value_1.value1;
+                valueSerializer.writeNumber(value_color_value_1_1);
+            }
+            else if (value_color_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_color_value_1_2 = value_color_value_1.value2;
+                valueSerializer.writeString(value_color_value_1_2);
+            }
+            else if (value_color_value_1_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_color_value_1_3 = value_color_value_1.value3;
+                Resource_serializer::write(valueSerializer, value_color_value_1_3);
             }
         }
+        else if (value_color_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_color_value_2 = value_color_value.value2;
+            LocalizedEdgeColors_serializer::write(valueSerializer, value_color_value_2);
+        }
     }
-    const auto value_heightAdaptivePolicy = value.heightAdaptivePolicy;
-    Ark_Int32 value_heightAdaptivePolicy_type = INTEROP_RUNTIME_UNDEFINED;
-    value_heightAdaptivePolicy_type = runtimeType(value_heightAdaptivePolicy);
-    valueSerializer.writeInt8(value_heightAdaptivePolicy_type);
-    if ((value_heightAdaptivePolicy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_heightAdaptivePolicy_value = value_heightAdaptivePolicy.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextHeightAdaptivePolicy>(value_heightAdaptivePolicy_value));
-    }
-    const auto value_font = value.font;
-    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
-    value_font_type = runtimeType(value_font);
-    valueSerializer.writeInt8(value_font_type);
-    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_font_value = value_font.value;
-        Font_serializer::write(valueSerializer, value_font_value);
-    }
-    const auto value_selectedColor = value.selectedColor;
-    Ark_Int32 value_selectedColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_selectedColor_type = runtimeType(value_selectedColor);
-    valueSerializer.writeInt8(value_selectedColor_type);
-    if ((value_selectedColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_selectedColor_value = value_selectedColor.value;
-        Ark_Int32 value_selectedColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_selectedColor_value_type = value_selectedColor_value.selector;
-        if (value_selectedColor_value_type == 0) {
+    const auto value_radius = value.radius;
+    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_radius_type = runtimeType(value_radius);
+    valueSerializer.writeInt8(value_radius_type);
+    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_radius_value = value_radius.value;
+        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_radius_value_type = value_radius_value.selector;
+        if (value_radius_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_selectedColor_value_0 = value_selectedColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_selectedColor_value_0));
+            const auto value_radius_value_0 = value_radius_value.value0;
+            OutlineRadiuses_serializer::write(valueSerializer, value_radius_value_0);
         }
-        else if (value_selectedColor_value_type == 1) {
+        else if ((value_radius_value_type == 1) || (value_radius_value_type == 1) || (value_radius_value_type == 1)) {
             valueSerializer.writeInt8(1);
-            const auto value_selectedColor_value_1 = value_selectedColor_value.value1;
-            valueSerializer.writeNumber(value_selectedColor_value_1);
-        }
-        else if (value_selectedColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_selectedColor_value_2 = value_selectedColor_value.value2;
-            valueSerializer.writeString(value_selectedColor_value_2);
-        }
-        else if (value_selectedColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_selectedColor_value_3 = value_selectedColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_selectedColor_value_3);
+            const auto value_radius_value_1 = value_radius_value.value1;
+            Ark_Int32 value_radius_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_radius_value_1_type = value_radius_value_1.selector;
+            if (value_radius_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_radius_value_1_0 = value_radius_value_1.value0;
+                valueSerializer.writeString(value_radius_value_1_0);
+            }
+            else if (value_radius_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_radius_value_1_1 = value_radius_value_1.value1;
+                valueSerializer.writeNumber(value_radius_value_1_1);
+            }
+            else if (value_radius_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_radius_value_1_2 = value_radius_value_1.value2;
+                Resource_serializer::write(valueSerializer, value_radius_value_1_2);
+            }
         }
     }
-    const auto value_unselectedColor = value.unselectedColor;
-    Ark_Int32 value_unselectedColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_unselectedColor_type = runtimeType(value_unselectedColor);
-    valueSerializer.writeInt8(value_unselectedColor_type);
-    if ((value_unselectedColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_unselectedColor_value = value_unselectedColor.value;
-        Ark_Int32 value_unselectedColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_unselectedColor_value_type = value_unselectedColor_value.selector;
-        if (value_unselectedColor_value_type == 0) {
+    const auto value_style = value.style;
+    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
+    value_style_type = runtimeType(value_style);
+    valueSerializer.writeInt8(value_style_type);
+    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_style_value = value_style.value;
+        Ark_Int32 value_style_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_style_value_type = value_style_value.selector;
+        if (value_style_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_unselectedColor_value_0 = value_unselectedColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_unselectedColor_value_0));
+            const auto value_style_value_0 = value_style_value.value0;
+            EdgeOutlineStyles_serializer::write(valueSerializer, value_style_value_0);
         }
-        else if (value_unselectedColor_value_type == 1) {
+        else if (value_style_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_unselectedColor_value_1 = value_unselectedColor_value.value1;
-            valueSerializer.writeNumber(value_unselectedColor_value_1);
-        }
-        else if (value_unselectedColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_unselectedColor_value_2 = value_unselectedColor_value.value2;
-            valueSerializer.writeString(value_unselectedColor_value_2);
-        }
-        else if (value_unselectedColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_unselectedColor_value_3 = value_unselectedColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_unselectedColor_value_3);
+            const auto value_style_value_1 = value_style_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_OutlineStyle>(value_style_value_1));
         }
     }
 }
-inline Ark_TabBarLabelStyle TabBarLabelStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_OutlineOptions OutlineOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_TabBarLabelStyle value = {};
+    Ark_OutlineOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextOverflow overflow_buf = {};
-    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
-    }
-    value.overflow = overflow_buf;
-    const auto maxLines_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number maxLines_buf = {};
-    maxLines_buf.tag = maxLines_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maxLines_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_EdgeOutlineWidths_Dimension width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        maxLines_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_EdgeOutlineWidths_Dimension width_buf_ = {};
+        width_buf_.selector = width_buf__selector;
+        if (width_buf__selector == 0) {
+            width_buf_.selector = 0;
+            width_buf_.value0 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+        }
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            const Ark_Int8 width_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension width_buf__u = {};
+            width_buf__u.selector = width_buf__u_selector;
+            if (width_buf__u_selector == 0) {
+                width_buf__u.selector = 0;
+                width_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (width_buf__u_selector == 1) {
+                width_buf__u.selector = 1;
+                width_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (width_buf__u_selector == 2) {
+                width_buf__u.selector = 2;
+                width_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for width_buf__u has to be chosen through deserialisation.");
+            }
+            width_buf_.value1 = static_cast<Ark_Dimension>(width_buf__u);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+        }
+        width_buf.value = static_cast<Ark_Union_EdgeOutlineWidths_Dimension>(width_buf_);
     }
-    value.maxLines = maxLines_buf;
-    const auto minFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_ResourceStr minFontSize_buf = {};
-    minFontSize_buf.tag = minFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((minFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.width = width_buf;
+    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_EdgeColors_ResourceColor_LocalizedEdgeColors color_buf = {};
+    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 minFontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_ResourceStr minFontSize_buf_ = {};
-        minFontSize_buf_.selector = minFontSize_buf__selector;
-        if (minFontSize_buf__selector == 0) {
-            minFontSize_buf_.selector = 0;
-            minFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_EdgeColors_ResourceColor_LocalizedEdgeColors color_buf_ = {};
+        color_buf_.selector = color_buf__selector;
+        if (color_buf__selector == 0) {
+            color_buf_.selector = 0;
+            color_buf_.value0 = EdgeColors_serializer::read(valueDeserializer);
         }
-        else if (minFontSize_buf__selector == 1) {
-            minFontSize_buf_.selector = 1;
-            const Ark_Int8 minFontSize_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceStr minFontSize_buf__u = {};
-            minFontSize_buf__u.selector = minFontSize_buf__u_selector;
-            if (minFontSize_buf__u_selector == 0) {
-                minFontSize_buf__u.selector = 0;
-                minFontSize_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (color_buf__selector == 1) {
+            color_buf_.selector = 1;
+            const Ark_Int8 color_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor color_buf__u = {};
+            color_buf__u.selector = color_buf__u_selector;
+            if (color_buf__u_selector == 0) {
+                color_buf__u.selector = 0;
+                color_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
             }
-            else if (minFontSize_buf__u_selector == 1) {
-                minFontSize_buf__u.selector = 1;
-                minFontSize_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            else if (color_buf__u_selector == 1) {
+                color_buf__u.selector = 1;
+                color_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (color_buf__u_selector == 2) {
+                color_buf__u.selector = 2;
+                color_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (color_buf__u_selector == 3) {
+                color_buf__u.selector = 3;
+                color_buf__u.value3 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for minFontSize_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for color_buf__u has to be chosen through deserialisation.");
             }
-            minFontSize_buf_.value1 = static_cast<Ark_ResourceStr>(minFontSize_buf__u);
+            color_buf_.value1 = static_cast<Ark_ResourceColor>(color_buf__u);
+        }
+        else if (color_buf__selector == 2) {
+            color_buf_.selector = 2;
+            color_buf_.value2 = LocalizedEdgeColors_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for minFontSize_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
         }
-        minFontSize_buf.value = static_cast<Ark_Union_Number_ResourceStr>(minFontSize_buf_);
+        color_buf.value = static_cast<Ark_Union_EdgeColors_ResourceColor_LocalizedEdgeColors>(color_buf_);
     }
-    value.minFontSize = minFontSize_buf;
-    const auto maxFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_ResourceStr maxFontSize_buf = {};
-    maxFontSize_buf.tag = maxFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maxFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.color = color_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_OutlineRadiuses_Dimension radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 maxFontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_ResourceStr maxFontSize_buf_ = {};
-        maxFontSize_buf_.selector = maxFontSize_buf__selector;
-        if (maxFontSize_buf__selector == 0) {
-            maxFontSize_buf_.selector = 0;
-            maxFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_OutlineRadiuses_Dimension radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            radius_buf_.value0 = OutlineRadiuses_serializer::read(valueDeserializer);
         }
-        else if (maxFontSize_buf__selector == 1) {
-            maxFontSize_buf_.selector = 1;
-            const Ark_Int8 maxFontSize_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceStr maxFontSize_buf__u = {};
-            maxFontSize_buf__u.selector = maxFontSize_buf__u_selector;
-            if (maxFontSize_buf__u_selector == 0) {
-                maxFontSize_buf__u.selector = 0;
-                maxFontSize_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            const Ark_Int8 radius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension radius_buf__u = {};
+            radius_buf__u.selector = radius_buf__u_selector;
+            if (radius_buf__u_selector == 0) {
+                radius_buf__u.selector = 0;
+                radius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (maxFontSize_buf__u_selector == 1) {
-                maxFontSize_buf__u.selector = 1;
-                maxFontSize_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            else if (radius_buf__u_selector == 1) {
+                radius_buf__u.selector = 1;
+                radius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (radius_buf__u_selector == 2) {
+                radius_buf__u.selector = 2;
+                radius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for maxFontSize_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for radius_buf__u has to be chosen through deserialisation.");
             }
-            maxFontSize_buf_.value1 = static_cast<Ark_ResourceStr>(maxFontSize_buf__u);
+            radius_buf_.value1 = static_cast<Ark_Dimension>(radius_buf__u);
         }
         else {
-            INTEROP_FATAL("One of the branches for maxFontSize_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
         }
-        maxFontSize_buf.value = static_cast<Ark_Union_Number_ResourceStr>(maxFontSize_buf_);
+        radius_buf.value = static_cast<Ark_Union_OutlineRadiuses_Dimension>(radius_buf_);
     }
-    value.maxFontSize = maxFontSize_buf;
-    const auto heightAdaptivePolicy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextHeightAdaptivePolicy heightAdaptivePolicy_buf = {};
-    heightAdaptivePolicy_buf.tag = heightAdaptivePolicy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((heightAdaptivePolicy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.radius = radius_buf;
+    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_EdgeOutlineStyles_OutlineStyle style_buf = {};
+    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        heightAdaptivePolicy_buf.value = static_cast<Ark_TextHeightAdaptivePolicy>(valueDeserializer.readInt32());
-    }
-    value.heightAdaptivePolicy = heightAdaptivePolicy_buf;
-    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Font font_buf = {};
-    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        font_buf.value = Font_serializer::read(valueDeserializer);
-    }
-    value.font = font_buf;
-    const auto selectedColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor selectedColor_buf = {};
-    selectedColor_buf.tag = selectedColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((selectedColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 selectedColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor selectedColor_buf_ = {};
-        selectedColor_buf_.selector = selectedColor_buf__selector;
-        if (selectedColor_buf__selector == 0) {
-            selectedColor_buf_.selector = 0;
-            selectedColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (selectedColor_buf__selector == 1) {
-            selectedColor_buf_.selector = 1;
-            selectedColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (selectedColor_buf__selector == 2) {
-            selectedColor_buf_.selector = 2;
-            selectedColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (selectedColor_buf__selector == 3) {
-            selectedColor_buf_.selector = 3;
-            selectedColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for selectedColor_buf_ has to be chosen through deserialisation.");
-        }
-        selectedColor_buf.value = static_cast<Ark_ResourceColor>(selectedColor_buf_);
-    }
-    value.selectedColor = selectedColor_buf;
-    const auto unselectedColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor unselectedColor_buf = {};
-    unselectedColor_buf.tag = unselectedColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((unselectedColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 unselectedColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor unselectedColor_buf_ = {};
-        unselectedColor_buf_.selector = unselectedColor_buf__selector;
-        if (unselectedColor_buf__selector == 0) {
-            unselectedColor_buf_.selector = 0;
-            unselectedColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (unselectedColor_buf__selector == 1) {
-            unselectedColor_buf_.selector = 1;
-            unselectedColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (unselectedColor_buf__selector == 2) {
-            unselectedColor_buf_.selector = 2;
-            unselectedColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 style_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_EdgeOutlineStyles_OutlineStyle style_buf_ = {};
+        style_buf_.selector = style_buf__selector;
+        if (style_buf__selector == 0) {
+            style_buf_.selector = 0;
+            style_buf_.value0 = EdgeOutlineStyles_serializer::read(valueDeserializer);
         }
-        else if (unselectedColor_buf__selector == 3) {
-            unselectedColor_buf_.selector = 3;
-            unselectedColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (style_buf__selector == 1) {
+            style_buf_.selector = 1;
+            style_buf_.value1 = static_cast<Ark_OutlineStyle>(valueDeserializer.readInt32());
         }
         else {
-            INTEROP_FATAL("One of the branches for unselectedColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for style_buf_ has to be chosen through deserialisation.");
         }
-        unselectedColor_buf.value = static_cast<Ark_ResourceColor>(unselectedColor_buf_);
+        style_buf.value = static_cast<Ark_Union_EdgeOutlineStyles_OutlineStyle>(style_buf_);
     }
-    value.unselectedColor = unselectedColor_buf;
+    value.style = style_buf;
     return value;
 }
-inline void TapGestureEvent_serializer::write(SerializerBase& buffer, Ark_TapGestureEvent value)
+inline void PanGestureEvent_serializer::write(SerializerBase& buffer, Ark_PanGestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
     valueSerializer.writePointer(value);
 }
-inline Ark_TapGestureEvent TapGestureEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_PanGestureEvent PanGestureEvent_serializer::read(DeserializerBase& buffer)
 {
     DeserializerBase& valueDeserializer = buffer;
     Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_TapGestureEvent>(ptr);
+    return static_cast<Ark_PanGestureEvent>(ptr);
 }
-inline void text_ParagraphStyle_serializer::write(SerializerBase& buffer, Ark_text_ParagraphStyle value)
+inline void ParagraphStyle_serializer::write(SerializerBase& buffer, Ark_ParagraphStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_textStyle = value.textStyle;
-    Ark_Int32 value_textStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textStyle_type = runtimeType(value_textStyle);
-    valueSerializer.writeInt8(value_textStyle_type);
-    if ((value_textStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textStyle_value = value_textStyle.value;
-        text_TextStyle_serializer::write(valueSerializer, value_textStyle_value);
-    }
-    const auto value_textDirection = value.textDirection;
-    Ark_Int32 value_textDirection_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textDirection_type = runtimeType(value_textDirection);
-    valueSerializer.writeInt8(value_textDirection_type);
-    if ((value_textDirection_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textDirection_value = value_textDirection.value;
-        valueSerializer.writeInt32(static_cast<Ark_text_TextDirection>(value_textDirection_value));
-    }
-    const auto value_align = value.align;
-    Ark_Int32 value_align_type = INTEROP_RUNTIME_UNDEFINED;
-    value_align_type = runtimeType(value_align);
-    valueSerializer.writeInt8(value_align_type);
-    if ((value_align_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_align_value = value_align.value;
-        valueSerializer.writeInt32(static_cast<Ark_text_TextAlign>(value_align_value));
+    valueSerializer.writePointer(value);
+}
+inline Ark_ParagraphStyle ParagraphStyle_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_ParagraphStyle>(ptr);
+}
+inline void ParagraphStyleInterface_serializer::write(SerializerBase& buffer, Ark_ParagraphStyleInterface value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_textAlign = value.textAlign;
+    Ark_Int32 value_textAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textAlign_type = runtimeType(value_textAlign);
+    valueSerializer.writeInt8(value_textAlign_type);
+    if ((value_textAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textAlign_value = value_textAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextAlign>(value_textAlign_value));
     }
-    const auto value_wordBreak = value.wordBreak;
-    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
-    value_wordBreak_type = runtimeType(value_wordBreak);
-    valueSerializer.writeInt8(value_wordBreak_type);
-    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_wordBreak_value = value_wordBreak.value;
-        valueSerializer.writeInt32(static_cast<Ark_text_WordBreak>(value_wordBreak_value));
+    const auto value_textIndent = value.textIndent;
+    Ark_Int32 value_textIndent_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textIndent_type = runtimeType(value_textIndent);
+    valueSerializer.writeInt8(value_textIndent_type);
+    if ((value_textIndent_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textIndent_value = value_textIndent.value;
+        LengthMetrics_serializer::write(valueSerializer, value_textIndent_value);
     }
     const auto value_maxLines = value.maxLines;
     Ark_Int32 value_maxLines_type = INTEROP_RUNTIME_UNDEFINED;
@@ -109960,75 +111466,70 @@ inline void text_ParagraphStyle_serializer::write(SerializerBase& buffer, Ark_te
         const auto value_maxLines_value = value_maxLines.value;
         valueSerializer.writeNumber(value_maxLines_value);
     }
-    const auto value_breakStrategy = value.breakStrategy;
-    Ark_Int32 value_breakStrategy_type = INTEROP_RUNTIME_UNDEFINED;
-    value_breakStrategy_type = runtimeType(value_breakStrategy);
-    valueSerializer.writeInt8(value_breakStrategy_type);
-    if ((value_breakStrategy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_breakStrategy_value = value_breakStrategy.value;
-        valueSerializer.writeInt32(static_cast<Ark_text_BreakStrategy>(value_breakStrategy_value));
+    const auto value_overflow = value.overflow;
+    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_overflow_type = runtimeType(value_overflow);
+    valueSerializer.writeInt8(value_overflow_type);
+    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_overflow_value = value_overflow.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
     }
-    const auto value_strutStyle = value.strutStyle;
-    Ark_Int32 value_strutStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_strutStyle_type = runtimeType(value_strutStyle);
-    valueSerializer.writeInt8(value_strutStyle_type);
-    if ((value_strutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_strutStyle_value = value_strutStyle.value;
-        text_StrutStyle_serializer::write(valueSerializer, value_strutStyle_value);
+    const auto value_wordBreak = value.wordBreak;
+    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
+    value_wordBreak_type = runtimeType(value_wordBreak);
+    valueSerializer.writeInt8(value_wordBreak_type);
+    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_wordBreak_value = value_wordBreak.value;
+        valueSerializer.writeInt32(static_cast<Ark_WordBreak>(value_wordBreak_value));
     }
-    const auto value_textHeightBehavior = value.textHeightBehavior;
-    Ark_Int32 value_textHeightBehavior_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textHeightBehavior_type = runtimeType(value_textHeightBehavior);
-    valueSerializer.writeInt8(value_textHeightBehavior_type);
-    if ((value_textHeightBehavior_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textHeightBehavior_value = value_textHeightBehavior.value;
-        valueSerializer.writeInt32(static_cast<Ark_text_TextHeightBehavior>(value_textHeightBehavior_value));
+    const auto value_leadingMargin = value.leadingMargin;
+    Ark_Int32 value_leadingMargin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_leadingMargin_type = runtimeType(value_leadingMargin);
+    valueSerializer.writeInt8(value_leadingMargin_type);
+    if ((value_leadingMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_leadingMargin_value = value_leadingMargin.value;
+        Ark_Int32 value_leadingMargin_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_leadingMargin_value_type = value_leadingMargin_value.selector;
+        if (value_leadingMargin_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_leadingMargin_value_0 = value_leadingMargin_value.value0;
+            LengthMetrics_serializer::write(valueSerializer, value_leadingMargin_value_0);
+        }
+        else if (value_leadingMargin_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_leadingMargin_value_1 = value_leadingMargin_value.value1;
+            LeadingMarginPlaceholder_serializer::write(valueSerializer, value_leadingMargin_value_1);
+        }
     }
-    const auto value_tab = value.tab;
-    Ark_Int32 value_tab_type = INTEROP_RUNTIME_UNDEFINED;
-    value_tab_type = runtimeType(value_tab);
-    valueSerializer.writeInt8(value_tab_type);
-    if ((value_tab_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_tab_value = value_tab.value;
-        text_TextTab_serializer::write(valueSerializer, value_tab_value);
+    const auto value_paragraphSpacing = value.paragraphSpacing;
+    Ark_Int32 value_paragraphSpacing_type = INTEROP_RUNTIME_UNDEFINED;
+    value_paragraphSpacing_type = runtimeType(value_paragraphSpacing);
+    valueSerializer.writeInt8(value_paragraphSpacing_type);
+    if ((value_paragraphSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_paragraphSpacing_value = value_paragraphSpacing.value;
+        LengthMetrics_serializer::write(valueSerializer, value_paragraphSpacing_value);
     }
 }
-inline Ark_text_ParagraphStyle text_ParagraphStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_ParagraphStyleInterface ParagraphStyleInterface_serializer::read(DeserializerBase& buffer)
 {
-    Ark_text_ParagraphStyle value = {};
+    Ark_ParagraphStyleInterface value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto textStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_TextStyle textStyle_buf = {};
-    textStyle_buf.tag = textStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textStyle_buf.value = text_TextStyle_serializer::read(valueDeserializer);
-    }
-    value.textStyle = textStyle_buf;
-    const auto textDirection_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_TextDirection textDirection_buf = {};
-    textDirection_buf.tag = textDirection_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textDirection_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textDirection_buf.value = static_cast<Ark_text_TextDirection>(valueDeserializer.readInt32());
-    }
-    value.textDirection = textDirection_buf;
-    const auto align_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_TextAlign align_buf = {};
-    align_buf.tag = align_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((align_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto textAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextAlign textAlign_buf = {};
+    textAlign_buf.tag = textAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        align_buf.value = static_cast<Ark_text_TextAlign>(valueDeserializer.readInt32());
+        textAlign_buf.value = static_cast<Ark_TextAlign>(valueDeserializer.readInt32());
     }
-    value.align = align_buf;
-    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_WordBreak wordBreak_buf = {};
-    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.textAlign = textAlign_buf;
+    const auto textIndent_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LengthMetrics textIndent_buf = {};
+    textIndent_buf.tag = textIndent_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textIndent_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        wordBreak_buf.value = static_cast<Ark_text_WordBreak>(valueDeserializer.readInt32());
+        textIndent_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
     }
-    value.wordBreak = wordBreak_buf;
+    value.textIndent = textIndent_buf;
     const auto maxLines_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Number maxLines_buf = {};
     maxLines_buf.tag = maxLines_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -110037,201 +111538,479 @@ inline Ark_text_ParagraphStyle text_ParagraphStyle_serializer::read(Deserializer
         maxLines_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
     value.maxLines = maxLines_buf;
-    const auto breakStrategy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_BreakStrategy breakStrategy_buf = {};
-    breakStrategy_buf.tag = breakStrategy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((breakStrategy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextOverflow overflow_buf = {};
+    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        breakStrategy_buf.value = static_cast<Ark_text_BreakStrategy>(valueDeserializer.readInt32());
+        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
     }
-    value.breakStrategy = breakStrategy_buf;
-    const auto strutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_StrutStyle strutStyle_buf = {};
-    strutStyle_buf.tag = strutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((strutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.overflow = overflow_buf;
+    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_WordBreak wordBreak_buf = {};
+    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        strutStyle_buf.value = text_StrutStyle_serializer::read(valueDeserializer);
+        wordBreak_buf.value = static_cast<Ark_WordBreak>(valueDeserializer.readInt32());
     }
-    value.strutStyle = strutStyle_buf;
-    const auto textHeightBehavior_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_TextHeightBehavior textHeightBehavior_buf = {};
-    textHeightBehavior_buf.tag = textHeightBehavior_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textHeightBehavior_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.wordBreak = wordBreak_buf;
+    const auto leadingMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_LengthMetrics_LeadingMarginPlaceholder leadingMargin_buf = {};
+    leadingMargin_buf.tag = leadingMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((leadingMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        textHeightBehavior_buf.value = static_cast<Ark_text_TextHeightBehavior>(valueDeserializer.readInt32());
+        const Ark_Int8 leadingMargin_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_LengthMetrics_LeadingMarginPlaceholder leadingMargin_buf_ = {};
+        leadingMargin_buf_.selector = leadingMargin_buf__selector;
+        if (leadingMargin_buf__selector == 0) {
+            leadingMargin_buf_.selector = 0;
+            leadingMargin_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        }
+        else if (leadingMargin_buf__selector == 1) {
+            leadingMargin_buf_.selector = 1;
+            leadingMargin_buf_.value1 = LeadingMarginPlaceholder_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for leadingMargin_buf_ has to be chosen through deserialisation.");
+        }
+        leadingMargin_buf.value = static_cast<Ark_Union_LengthMetrics_LeadingMarginPlaceholder>(leadingMargin_buf_);
     }
-    value.textHeightBehavior = textHeightBehavior_buf;
-    const auto tab_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_text_TextTab tab_buf = {};
-    tab_buf.tag = tab_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((tab_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.leadingMargin = leadingMargin_buf;
+    const auto paragraphSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LengthMetrics paragraphSpacing_buf = {};
+    paragraphSpacing_buf.tag = paragraphSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((paragraphSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        tab_buf.value = text_TextTab_serializer::read(valueDeserializer);
+        paragraphSpacing_buf.value = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
     }
-    value.tab = tab_buf;
-    return value;
-}
-inline void text_RunMetrics_serializer::write(SerializerBase& buffer, Ark_text_RunMetrics value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_textStyle = value.textStyle;
-    text_TextStyle_serializer::write(valueSerializer, value_textStyle);
-    const auto value_fontMetrics = value.fontMetrics;
-    drawing_FontMetrics_serializer::write(valueSerializer, value_fontMetrics);
-}
-inline Ark_text_RunMetrics text_RunMetrics_serializer::read(DeserializerBase& buffer)
-{
-    Ark_text_RunMetrics value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.textStyle = text_TextStyle_serializer::read(valueDeserializer);
-    value.fontMetrics = drawing_FontMetrics_serializer::read(valueDeserializer);
+    value.paragraphSpacing = paragraphSpacing_buf;
     return value;
 }
-inline void TextBackgroundStyle_serializer::write(SerializerBase& buffer, Ark_TextBackgroundStyle value)
+inline void PickerDialogButtonStyle_serializer::write(SerializerBase& buffer, Ark_PickerDialogButtonStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_color = value.color;
-    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
-    value_color_type = runtimeType(value_color);
-    valueSerializer.writeInt8(value_color_type);
-    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_color_value = value_color.value;
-        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_color_value_type = value_color_value.selector;
-        if (value_color_value_type == 0) {
+    const auto value_type = value.type;
+    Ark_Int32 value_type_type = INTEROP_RUNTIME_UNDEFINED;
+    value_type_type = runtimeType(value_type);
+    valueSerializer.writeInt8(value_type_type);
+    if ((value_type_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_type_value = value_type.value;
+        valueSerializer.writeInt32(static_cast<Ark_ButtonType>(value_type_value));
+    }
+    const auto value_style = value.style;
+    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
+    value_style_type = runtimeType(value_style);
+    valueSerializer.writeInt8(value_style_type);
+    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_style_value = value_style.value;
+        valueSerializer.writeInt32(static_cast<Ark_ButtonStyleMode>(value_style_value));
+    }
+    const auto value_role = value.role;
+    Ark_Int32 value_role_type = INTEROP_RUNTIME_UNDEFINED;
+    value_role_type = runtimeType(value_role);
+    valueSerializer.writeInt8(value_role_type);
+    if ((value_role_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_role_value = value_role.value;
+        valueSerializer.writeInt32(static_cast<Ark_ButtonRole>(value_role_value));
+    }
+    const auto value_fontSize = value.fontSize;
+    Ark_Int32 value_fontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontSize_type = runtimeType(value_fontSize);
+    valueSerializer.writeInt8(value_fontSize_type);
+    if ((value_fontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontSize_value = value_fontSize.value;
+        Ark_Int32 value_fontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontSize_value_type = value_fontSize_value.selector;
+        if (value_fontSize_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_color_value_0 = value_color_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0));
+            const auto value_fontSize_value_0 = value_fontSize_value.value0;
+            valueSerializer.writeString(value_fontSize_value_0);
         }
-        else if (value_color_value_type == 1) {
+        else if (value_fontSize_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_color_value_1 = value_color_value.value1;
-            valueSerializer.writeNumber(value_color_value_1);
+            const auto value_fontSize_value_1 = value_fontSize_value.value1;
+            valueSerializer.writeNumber(value_fontSize_value_1);
         }
-        else if (value_color_value_type == 2) {
+        else if (value_fontSize_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_color_value_2 = value_color_value.value2;
-            valueSerializer.writeString(value_color_value_2);
-        }
-        else if (value_color_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_color_value_3 = value_color_value.value3;
-            Resource_serializer::write(valueSerializer, value_color_value_3);
+            const auto value_fontSize_value_2 = value_fontSize_value.value2;
+            Resource_serializer::write(valueSerializer, value_fontSize_value_2);
         }
     }
-    const auto value_radius = value.radius;
-    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_radius_type = runtimeType(value_radius);
-    valueSerializer.writeInt8(value_radius_type);
-    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_radius_value = value_radius.value;
-        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_radius_value_type = value_radius_value.selector;
-        if ((value_radius_value_type == 0) || (value_radius_value_type == 0) || (value_radius_value_type == 0)) {
+    const auto value_fontColor = value.fontColor;
+    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontColor_type = runtimeType(value_fontColor);
+    valueSerializer.writeInt8(value_fontColor_type);
+    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontColor_value = value_fontColor.value;
+        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontColor_value_type = value_fontColor_value.selector;
+        if (value_fontColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_radius_value_0 = value_radius_value.value0;
-            Ark_Int32 value_radius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_radius_value_0_type = value_radius_value_0.selector;
-            if (value_radius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_radius_value_0_0 = value_radius_value_0.value0;
-                valueSerializer.writeString(value_radius_value_0_0);
-            }
-            else if (value_radius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_radius_value_0_1 = value_radius_value_0.value1;
-                valueSerializer.writeNumber(value_radius_value_0_1);
-            }
-            else if (value_radius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_radius_value_0_2 = value_radius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_radius_value_0_2);
-            }
+            const auto value_fontColor_value_0 = value_fontColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
         }
-        else if (value_radius_value_type == 1) {
+        else if (value_fontColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_radius_value_1 = value_radius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_radius_value_1);
+            const auto value_fontColor_value_1 = value_fontColor_value.value1;
+            valueSerializer.writeNumber(value_fontColor_value_1);
         }
-    }
-}
-inline Ark_TextBackgroundStyle TextBackgroundStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_TextBackgroundStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor color_buf = {};
-    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor color_buf_ = {};
-        color_buf_.selector = color_buf__selector;
-        if (color_buf__selector == 0) {
-            color_buf_.selector = 0;
-            color_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        else if (value_fontColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_fontColor_value_2 = value_fontColor_value.value2;
+            valueSerializer.writeString(value_fontColor_value_2);
         }
-        else if (color_buf__selector == 1) {
-            color_buf_.selector = 1;
-            color_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (value_fontColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_fontColor_value_3 = value_fontColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
         }
-        else if (color_buf__selector == 2) {
-            color_buf_.selector = 2;
-            color_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    const auto value_fontWeight = value.fontWeight;
+    Ark_Int32 value_fontWeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontWeight_type = runtimeType(value_fontWeight);
+    valueSerializer.writeInt8(value_fontWeight_type);
+    if ((value_fontWeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontWeight_value = value_fontWeight.value;
+        Ark_Int32 value_fontWeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontWeight_value_type = value_fontWeight_value.selector;
+        if (value_fontWeight_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_fontWeight_value_0 = value_fontWeight_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_FontWeight>(value_fontWeight_value_0));
         }
-        else if (color_buf__selector == 3) {
-            color_buf_.selector = 3;
-            color_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (value_fontWeight_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_fontWeight_value_1 = value_fontWeight_value.value1;
+            valueSerializer.writeNumber(value_fontWeight_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
+        else if (value_fontWeight_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_fontWeight_value_2 = value_fontWeight_value.value2;
+            valueSerializer.writeString(value_fontWeight_value_2);
         }
-        color_buf.value = static_cast<Ark_ResourceColor>(color_buf_);
     }
-    value.color = color_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_BorderRadiuses radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_BorderRadiuses radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            const Ark_Int8 radius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension radius_buf__u = {};
-            radius_buf__u.selector = radius_buf__u_selector;
-            if (radius_buf__u_selector == 0) {
-                radius_buf__u.selector = 0;
-                radius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+    const auto value_fontStyle = value.fontStyle;
+    Ark_Int32 value_fontStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontStyle_type = runtimeType(value_fontStyle);
+    valueSerializer.writeInt8(value_fontStyle_type);
+    if ((value_fontStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontStyle_value = value_fontStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle_value));
+    }
+    const auto value_fontFamily = value.fontFamily;
+    Ark_Int32 value_fontFamily_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontFamily_type = runtimeType(value_fontFamily);
+    valueSerializer.writeInt8(value_fontFamily_type);
+    if ((value_fontFamily_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontFamily_value = value_fontFamily.value;
+        Ark_Int32 value_fontFamily_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontFamily_value_type = value_fontFamily_value.selector;
+        if (value_fontFamily_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_fontFamily_value_0 = value_fontFamily_value.value0;
+            Resource_serializer::write(valueSerializer, value_fontFamily_value_0);
+        }
+        else if (value_fontFamily_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_fontFamily_value_1 = value_fontFamily_value.value1;
+            valueSerializer.writeString(value_fontFamily_value_1);
+        }
+    }
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+        }
+        else if (value_backgroundColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
+        }
+        else if (value_backgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
+        }
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+        }
+    }
+    const auto value_borderRadius = value.borderRadius;
+    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderRadius_type = runtimeType(value_borderRadius);
+    valueSerializer.writeInt8(value_borderRadius_type);
+    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderRadius_value = value_borderRadius.value;
+        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderRadius_value_type = value_borderRadius_value.selector;
+        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
+            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
+            if (value_borderRadius_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
+                valueSerializer.writeString(value_borderRadius_value_0_0);
             }
-            else if (radius_buf__u_selector == 1) {
-                radius_buf__u.selector = 1;
-                radius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (value_borderRadius_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_borderRadius_value_0_1);
             }
-            else if (radius_buf__u_selector == 2) {
-                radius_buf__u.selector = 2;
-                radius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (value_borderRadius_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
+            }
+        }
+        else if (value_borderRadius_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
+        }
+    }
+    const auto value_primary = value.primary;
+    Ark_Int32 value_primary_type = INTEROP_RUNTIME_UNDEFINED;
+    value_primary_type = runtimeType(value_primary);
+    valueSerializer.writeInt8(value_primary_type);
+    if ((value_primary_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_primary_value = value_primary.value;
+        valueSerializer.writeBoolean(value_primary_value);
+    }
+}
+inline Ark_PickerDialogButtonStyle PickerDialogButtonStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_PickerDialogButtonStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto type_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ButtonType type_buf = {};
+    type_buf.tag = type_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((type_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        type_buf.value = static_cast<Ark_ButtonType>(valueDeserializer.readInt32());
+    }
+    value.type = type_buf;
+    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ButtonStyleMode style_buf = {};
+    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        style_buf.value = static_cast<Ark_ButtonStyleMode>(valueDeserializer.readInt32());
+    }
+    value.style = style_buf;
+    const auto role_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ButtonRole role_buf = {};
+    role_buf.tag = role_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((role_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        role_buf.value = static_cast<Ark_ButtonRole>(valueDeserializer.readInt32());
+    }
+    value.role = role_buf;
+    const auto fontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length fontSize_buf = {};
+    fontSize_buf.tag = fontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 fontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Length fontSize_buf_ = {};
+        fontSize_buf_.selector = fontSize_buf__selector;
+        if (fontSize_buf__selector == 0) {
+            fontSize_buf_.selector = 0;
+            fontSize_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (fontSize_buf__selector == 1) {
+            fontSize_buf_.selector = 1;
+            fontSize_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (fontSize_buf__selector == 2) {
+            fontSize_buf_.selector = 2;
+            fontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for fontSize_buf_ has to be chosen through deserialisation.");
+        }
+        fontSize_buf.value = static_cast<Ark_Length>(fontSize_buf_);
+    }
+    value.fontSize = fontSize_buf;
+    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor fontColor_buf = {};
+    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor fontColor_buf_ = {};
+        fontColor_buf_.selector = fontColor_buf__selector;
+        if (fontColor_buf__selector == 0) {
+            fontColor_buf_.selector = 0;
+            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (fontColor_buf__selector == 1) {
+            fontColor_buf_.selector = 1;
+            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (fontColor_buf__selector == 2) {
+            fontColor_buf_.selector = 2;
+            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (fontColor_buf__selector == 3) {
+            fontColor_buf_.selector = 3;
+            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
+        }
+        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
+    }
+    value.fontColor = fontColor_buf;
+    const auto fontWeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_FontWeight_Number_String fontWeight_buf = {};
+    fontWeight_buf.tag = fontWeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontWeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 fontWeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_FontWeight_Number_String fontWeight_buf_ = {};
+        fontWeight_buf_.selector = fontWeight_buf__selector;
+        if (fontWeight_buf__selector == 0) {
+            fontWeight_buf_.selector = 0;
+            fontWeight_buf_.value0 = static_cast<Ark_FontWeight>(valueDeserializer.readInt32());
+        }
+        else if (fontWeight_buf__selector == 1) {
+            fontWeight_buf_.selector = 1;
+            fontWeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (fontWeight_buf__selector == 2) {
+            fontWeight_buf_.selector = 2;
+            fontWeight_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.");
+        }
+        fontWeight_buf.value = static_cast<Ark_Union_FontWeight_Number_String>(fontWeight_buf_);
+    }
+    value.fontWeight = fontWeight_buf;
+    const auto fontStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_FontStyle fontStyle_buf = {};
+    fontStyle_buf.tag = fontStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        fontStyle_buf.value = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
+    }
+    value.fontStyle = fontStyle_buf;
+    const auto fontFamily_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Resource_String fontFamily_buf = {};
+    fontFamily_buf.tag = fontFamily_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontFamily_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 fontFamily_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Resource_String fontFamily_buf_ = {};
+        fontFamily_buf_.selector = fontFamily_buf__selector;
+        if (fontFamily_buf__selector == 0) {
+            fontFamily_buf_.selector = 0;
+            fontFamily_buf_.value0 = Resource_serializer::read(valueDeserializer);
+        }
+        else if (fontFamily_buf__selector == 1) {
+            fontFamily_buf_.selector = 1;
+            fontFamily_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.");
+        }
+        fontFamily_buf.value = static_cast<Ark_Union_Resource_String>(fontFamily_buf_);
+    }
+    value.fontFamily = fontFamily_buf;
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        }
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
+    }
+    value.backgroundColor = backgroundColor_buf;
+    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_BorderRadiuses borderRadius_buf = {};
+    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_BorderRadiuses borderRadius_buf_ = {};
+        borderRadius_buf_.selector = borderRadius_buf__selector;
+        if (borderRadius_buf__selector == 0) {
+            borderRadius_buf_.selector = 0;
+            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length borderRadius_buf__u = {};
+            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
+            if (borderRadius_buf__u_selector == 0) {
+                borderRadius_buf__u.selector = 0;
+                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderRadius_buf__u_selector == 1) {
+                borderRadius_buf__u.selector = 1;
+                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderRadius_buf__u_selector == 2) {
+                borderRadius_buf__u.selector = 2;
+                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for radius_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
             }
-            radius_buf_.value0 = static_cast<Ark_Dimension>(radius_buf__u);
+            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
         }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            radius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        else if (borderRadius_buf__selector == 1) {
+            borderRadius_buf_.selector = 1;
+            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
         }
-        radius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(radius_buf_);
+        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses>(borderRadius_buf_);
     }
-    value.radius = radius_buf;
+    value.borderRadius = borderRadius_buf;
+    const auto primary_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean primary_buf = {};
+    primary_buf.tag = primary_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((primary_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        primary_buf.value = valueDeserializer.readBoolean();
+    }
+    value.primary = primary_buf;
     return value;
 }
-inline void TextPickerTextStyle_serializer::write(SerializerBase& buffer, Ark_TextPickerTextStyle value)
+inline void PickerTextStyle_serializer::write(SerializerBase& buffer, Ark_PickerTextStyle value)
 {
     SerializerBase& valueSerializer = buffer;
     const auto value_color = value.color;
@@ -110271,66 +112050,10 @@ inline void TextPickerTextStyle_serializer::write(SerializerBase& buffer, Ark_Te
         const auto value_font_value = value_font.value;
         Font_serializer::write(valueSerializer, value_font_value);
     }
-    const auto value_minFontSize = value.minFontSize;
-    Ark_Int32 value_minFontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_minFontSize_type = runtimeType(value_minFontSize);
-    valueSerializer.writeInt8(value_minFontSize_type);
-    if ((value_minFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_minFontSize_value = value_minFontSize.value;
-        Ark_Int32 value_minFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_minFontSize_value_type = value_minFontSize_value.selector;
-        if (value_minFontSize_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_minFontSize_value_0 = value_minFontSize_value.value0;
-            valueSerializer.writeNumber(value_minFontSize_value_0);
-        }
-        else if (value_minFontSize_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_minFontSize_value_1 = value_minFontSize_value.value1;
-            valueSerializer.writeString(value_minFontSize_value_1);
-        }
-        else if (value_minFontSize_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_minFontSize_value_2 = value_minFontSize_value.value2;
-            Resource_serializer::write(valueSerializer, value_minFontSize_value_2);
-        }
-    }
-    const auto value_maxFontSize = value.maxFontSize;
-    Ark_Int32 value_maxFontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maxFontSize_type = runtimeType(value_maxFontSize);
-    valueSerializer.writeInt8(value_maxFontSize_type);
-    if ((value_maxFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maxFontSize_value = value_maxFontSize.value;
-        Ark_Int32 value_maxFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_maxFontSize_value_type = value_maxFontSize_value.selector;
-        if (value_maxFontSize_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_maxFontSize_value_0 = value_maxFontSize_value.value0;
-            valueSerializer.writeNumber(value_maxFontSize_value_0);
-        }
-        else if (value_maxFontSize_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_maxFontSize_value_1 = value_maxFontSize_value.value1;
-            valueSerializer.writeString(value_maxFontSize_value_1);
-        }
-        else if (value_maxFontSize_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_maxFontSize_value_2 = value_maxFontSize_value.value2;
-            Resource_serializer::write(valueSerializer, value_maxFontSize_value_2);
-        }
-    }
-    const auto value_overflow = value.overflow;
-    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_overflow_type = runtimeType(value_overflow);
-    valueSerializer.writeInt8(value_overflow_type);
-    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_overflow_value = value_overflow.value;
-        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
-    }
 }
-inline Ark_TextPickerTextStyle TextPickerTextStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_PickerTextStyle PickerTextStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_TextPickerTextStyle value = {};
+    Ark_PickerTextStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
     const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_ResourceColor color_buf = {};
@@ -110370,546 +112093,374 @@ inline Ark_TextPickerTextStyle TextPickerTextStyle_serializer::read(Deserializer
         font_buf.value = Font_serializer::read(valueDeserializer);
     }
     value.font = font_buf;
-    const auto minFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_String_Resource minFontSize_buf = {};
-    minFontSize_buf.tag = minFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((minFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 minFontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_String_Resource minFontSize_buf_ = {};
-        minFontSize_buf_.selector = minFontSize_buf__selector;
-        if (minFontSize_buf__selector == 0) {
-            minFontSize_buf_.selector = 0;
-            minFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (minFontSize_buf__selector == 1) {
-            minFontSize_buf_.selector = 1;
-            minFontSize_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (minFontSize_buf__selector == 2) {
-            minFontSize_buf_.selector = 2;
-            minFontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for minFontSize_buf_ has to be chosen through deserialisation.");
-        }
-        minFontSize_buf.value = static_cast<Ark_Union_Number_String_Resource>(minFontSize_buf_);
-    }
-    value.minFontSize = minFontSize_buf;
-    const auto maxFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_String_Resource maxFontSize_buf = {};
-    maxFontSize_buf.tag = maxFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maxFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 maxFontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_String_Resource maxFontSize_buf_ = {};
-        maxFontSize_buf_.selector = maxFontSize_buf__selector;
-        if (maxFontSize_buf__selector == 0) {
-            maxFontSize_buf_.selector = 0;
-            maxFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (maxFontSize_buf__selector == 1) {
-            maxFontSize_buf_.selector = 1;
-            maxFontSize_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (maxFontSize_buf__selector == 2) {
-            maxFontSize_buf_.selector = 2;
-            maxFontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for maxFontSize_buf_ has to be chosen through deserialisation.");
-        }
-        maxFontSize_buf.value = static_cast<Ark_Union_Number_String_Resource>(maxFontSize_buf_);
-    }
-    value.maxFontSize = maxFontSize_buf;
-    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextOverflow overflow_buf = {};
-    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
-    }
-    value.overflow = overflow_buf;
     return value;
 }
-inline void TouchEvent_serializer::write(SerializerBase& buffer, Ark_TouchEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_TouchEvent TouchEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_TouchEvent>(ptr);
-}
-inline void AccessibilityHoverEvent_serializer::write(SerializerBase& buffer, Ark_AccessibilityHoverEvent value)
+inline void PinchGestureEvent_serializer::write(SerializerBase& buffer, Ark_PinchGestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
     valueSerializer.writePointer(value);
 }
-inline Ark_AccessibilityHoverEvent AccessibilityHoverEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_PinchGestureEvent PinchGestureEvent_serializer::read(DeserializerBase& buffer)
 {
     DeserializerBase& valueDeserializer = buffer;
     Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_AccessibilityHoverEvent>(ptr);
+    return static_cast<Ark_PinchGestureEvent>(ptr);
 }
-inline void AxisEvent_serializer::write(SerializerBase& buffer, Ark_AxisEvent value)
+inline void PlaceholderStyle_serializer::write(SerializerBase& buffer, Ark_PlaceholderStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
+    const auto value_font = value.font;
+    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
+    value_font_type = runtimeType(value_font);
+    valueSerializer.writeInt8(value_font_type);
+    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_font_value = value_font.value;
+        Font_serializer::write(valueSerializer, value_font_value);
+    }
+    const auto value_fontColor = value.fontColor;
+    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontColor_type = runtimeType(value_fontColor);
+    valueSerializer.writeInt8(value_fontColor_type);
+    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontColor_value = value_fontColor.value;
+        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontColor_value_type = value_fontColor_value.selector;
+        if (value_fontColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_fontColor_value_0 = value_fontColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
+        }
+        else if (value_fontColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_fontColor_value_1 = value_fontColor_value.value1;
+            valueSerializer.writeNumber(value_fontColor_value_1);
+        }
+        else if (value_fontColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_fontColor_value_2 = value_fontColor_value.value2;
+            valueSerializer.writeString(value_fontColor_value_2);
+        }
+        else if (value_fontColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_fontColor_value_3 = value_fontColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
+        }
+    }
 }
-inline Ark_AxisEvent AxisEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_PlaceholderStyle PlaceholderStyle_serializer::read(DeserializerBase& buffer)
 {
+    Ark_PlaceholderStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_AxisEvent>(ptr);
-}
-inline void BackgroundColorStyle_serializer::write(SerializerBase& buffer, Ark_BackgroundColorStyle value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_BackgroundColorStyle BackgroundColorStyle_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_BackgroundColorStyle>(ptr);
-}
-inline void BaseEvent_serializer::write(SerializerBase& buffer, Ark_BaseEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_BaseEvent BaseEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_BaseEvent>(ptr);
-}
-inline void BaseGestureEvent_serializer::write(SerializerBase& buffer, Ark_BaseGestureEvent value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_BaseGestureEvent BaseGestureEvent_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_BaseGestureEvent>(ptr);
+    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font font_buf = {};
+    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        font_buf.value = Font_serializer::read(valueDeserializer);
+    }
+    value.font = font_buf;
+    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor fontColor_buf = {};
+    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor fontColor_buf_ = {};
+        fontColor_buf_.selector = fontColor_buf__selector;
+        if (fontColor_buf__selector == 0) {
+            fontColor_buf_.selector = 0;
+            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (fontColor_buf__selector == 1) {
+            fontColor_buf_.selector = 1;
+            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (fontColor_buf__selector == 2) {
+            fontColor_buf_.selector = 2;
+            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (fontColor_buf__selector == 3) {
+            fontColor_buf_.selector = 3;
+            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
+        }
+        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
+    }
+    value.fontColor = fontColor_buf;
+    return value;
 }
-inline void BottomTabBarStyle_serializer::write(SerializerBase& buffer, Ark_BottomTabBarStyle value)
+inline void PopupCommonOptions_serializer::write(SerializerBase& buffer, Ark_PopupCommonOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value__icon = value._icon;
-    Ark_Int32 value__icon_type = INTEROP_RUNTIME_UNDEFINED;
-    value__icon_type = runtimeType(value__icon);
-    valueSerializer.writeInt8(value__icon_type);
-    if ((value__icon_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__icon_value = value__icon.value;
-        Ark_Int32 value__icon_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__icon_value_type = value__icon_value.selector;
-        if ((value__icon_value_type == 0) || (value__icon_value_type == 0)) {
+    const auto value_placement = value.placement;
+    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placement_type = runtimeType(value_placement);
+    valueSerializer.writeInt8(value_placement_type);
+    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placement_value = value_placement.value;
+        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
+    }
+    const auto value_popupColor = value.popupColor;
+    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_popupColor_type = runtimeType(value_popupColor);
+    valueSerializer.writeInt8(value_popupColor_type);
+    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_popupColor_value = value_popupColor.value;
+        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_popupColor_value_type = value_popupColor_value.selector;
+        if (value_popupColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__icon_value_0 = value__icon_value.value0;
-            Ark_Int32 value__icon_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value__icon_value_0_type = value__icon_value_0.selector;
-            if (value__icon_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value__icon_value_0_0 = value__icon_value_0.value0;
-                valueSerializer.writeString(value__icon_value_0_0);
-            }
-            else if (value__icon_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value__icon_value_0_1 = value__icon_value_0.value1;
-                Resource_serializer::write(valueSerializer, value__icon_value_0_1);
-            }
+            const auto value_popupColor_value_0 = value_popupColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
         }
-        else if (value__icon_value_type == 1) {
+        else if (value_popupColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__icon_value_1 = value__icon_value.value1;
-            TabBarSymbol_serializer::write(valueSerializer, value__icon_value_1);
+            const auto value_popupColor_value_1 = value_popupColor_value.value1;
+            valueSerializer.writeNumber(value_popupColor_value_1);
+        }
+        else if (value_popupColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_popupColor_value_2 = value_popupColor_value.value2;
+            valueSerializer.writeString(value_popupColor_value_2);
+        }
+        else if (value_popupColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_popupColor_value_3 = value_popupColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_popupColor_value_3);
         }
     }
-    const auto value__text = value._text;
-    Ark_Int32 value__text_type = INTEROP_RUNTIME_UNDEFINED;
-    value__text_type = runtimeType(value__text);
-    valueSerializer.writeInt8(value__text_type);
-    if ((value__text_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__text_value = value__text.value;
-        Ark_Int32 value__text_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__text_value_type = value__text_value.selector;
-        if (value__text_value_type == 0) {
+    const auto value_enableArrow = value.enableArrow;
+    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableArrow_type = runtimeType(value_enableArrow);
+    valueSerializer.writeInt8(value_enableArrow_type);
+    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableArrow_value = value_enableArrow.value;
+        valueSerializer.writeBoolean(value_enableArrow_value);
+    }
+    const auto value_autoCancel = value.autoCancel;
+    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_autoCancel_type = runtimeType(value_autoCancel);
+    valueSerializer.writeInt8(value_autoCancel_type);
+    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_autoCancel_value = value_autoCancel.value;
+        valueSerializer.writeBoolean(value_autoCancel_value);
+    }
+    const auto value_onStateChange = value.onStateChange;
+    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onStateChange_type = runtimeType(value_onStateChange);
+    valueSerializer.writeInt8(value_onStateChange_type);
+    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onStateChange_value = value_onStateChange.value;
+        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
+    }
+    const auto value_arrowOffset = value.arrowOffset;
+    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowOffset_type = runtimeType(value_arrowOffset);
+    valueSerializer.writeInt8(value_arrowOffset_type);
+    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowOffset_value = value_arrowOffset.value;
+        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowOffset_value_type = value_arrowOffset_value.selector;
+        if (value_arrowOffset_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__text_value_0 = value__text_value.value0;
-            valueSerializer.writeString(value__text_value_0);
+            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
+            valueSerializer.writeString(value_arrowOffset_value_0);
         }
-        else if (value__text_value_type == 1) {
+        else if (value_arrowOffset_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__text_value_1 = value__text_value.value1;
-            Resource_serializer::write(valueSerializer, value__text_value_1);
+            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
+            valueSerializer.writeNumber(value_arrowOffset_value_1);
+        }
+        else if (value_arrowOffset_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
         }
     }
-    const auto value__labelStyle = value._labelStyle;
-    Ark_Int32 value__labelStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value__labelStyle_type = runtimeType(value__labelStyle);
-    valueSerializer.writeInt8(value__labelStyle_type);
-    if ((value__labelStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__labelStyle_value = value__labelStyle.value;
-        TabBarLabelStyle_serializer::write(valueSerializer, value__labelStyle_value);
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
     }
-    const auto value__padding = value._padding;
-    Ark_Int32 value__padding_type = INTEROP_RUNTIME_UNDEFINED;
-    value__padding_type = runtimeType(value__padding);
-    valueSerializer.writeInt8(value__padding_type);
-    if ((value__padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__padding_value = value__padding.value;
-        Ark_Int32 value__padding_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__padding_value_type = value__padding_value.selector;
-        if (value__padding_value_type == 0) {
+    const auto value_mask = value.mask;
+    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
+    value_mask_type = runtimeType(value_mask);
+    valueSerializer.writeInt8(value_mask_type);
+    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_mask_value = value_mask.value;
+        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_mask_value_type = value_mask_value.selector;
+        if (value_mask_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__padding_value_0 = value__padding_value.value0;
-            Padding_serializer::write(valueSerializer, value__padding_value_0);
+            const auto value_mask_value_0 = value_mask_value.value0;
+            valueSerializer.writeBoolean(value_mask_value_0);
         }
-        else if ((value__padding_value_type == 1) || (value__padding_value_type == 1) || (value__padding_value_type == 1)) {
+        else if (value_mask_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value__padding_value_1 = value__padding_value.value1;
-            Ark_Int32 value__padding_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-            value__padding_value_1_type = value__padding_value_1.selector;
-            if (value__padding_value_1_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value__padding_value_1_0 = value__padding_value_1.value0;
-                valueSerializer.writeString(value__padding_value_1_0);
-            }
-            else if (value__padding_value_1_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value__padding_value_1_1 = value__padding_value_1.value1;
-                valueSerializer.writeNumber(value__padding_value_1_1);
-            }
-            else if (value__padding_value_1_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value__padding_value_1_2 = value__padding_value_1.value2;
-                Resource_serializer::write(valueSerializer, value__padding_value_1_2);
-            }
+            const auto value_mask_value_1 = value_mask_value.value1;
+            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
         }
-        else if (value__padding_value_type == 2) {
+    }
+    const auto value_targetSpace = value.targetSpace;
+    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_targetSpace_type = runtimeType(value_targetSpace);
+    valueSerializer.writeInt8(value_targetSpace_type);
+    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_targetSpace_value = value_targetSpace.value;
+        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_targetSpace_value_type = value_targetSpace_value.selector;
+        if (value_targetSpace_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
+            valueSerializer.writeString(value_targetSpace_value_0);
+        }
+        else if (value_targetSpace_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
+            valueSerializer.writeNumber(value_targetSpace_value_1);
+        }
+        else if (value_targetSpace_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value__padding_value_2 = value__padding_value.value2;
-            LocalizedPadding_serializer::write(valueSerializer, value__padding_value_2);
+            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
+            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
         }
     }
-    const auto value__layoutMode = value._layoutMode;
-    Ark_Int32 value__layoutMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value__layoutMode_type = runtimeType(value__layoutMode);
-    valueSerializer.writeInt8(value__layoutMode_type);
-    if ((value__layoutMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__layoutMode_value = value__layoutMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_LayoutMode>(value__layoutMode_value));
-    }
-    const auto value__verticalAlign = value._verticalAlign;
-    Ark_Int32 value__verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value__verticalAlign_type = runtimeType(value__verticalAlign);
-    valueSerializer.writeInt8(value__verticalAlign_type);
-    if ((value__verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__verticalAlign_value = value__verticalAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_VerticalAlign>(value__verticalAlign_value));
-    }
-    const auto value__symmetricExtensible = value._symmetricExtensible;
-    Ark_Int32 value__symmetricExtensible_type = INTEROP_RUNTIME_UNDEFINED;
-    value__symmetricExtensible_type = runtimeType(value__symmetricExtensible);
-    valueSerializer.writeInt8(value__symmetricExtensible_type);
-    if ((value__symmetricExtensible_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__symmetricExtensible_value = value__symmetricExtensible.value;
-        valueSerializer.writeBoolean(value__symmetricExtensible_value);
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Position_serializer::write(valueSerializer, value_offset_value);
     }
-    const auto value__id = value._id;
-    Ark_Int32 value__id_type = INTEROP_RUNTIME_UNDEFINED;
-    value__id_type = runtimeType(value__id);
-    valueSerializer.writeInt8(value__id_type);
-    if ((value__id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__id_value = value__id.value;
-        valueSerializer.writeString(value__id_value);
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if (value_width_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_width_value_0 = value_width_value.value0;
+            valueSerializer.writeString(value_width_value_0);
+        }
+        else if (value_width_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_width_value_1 = value_width_value.value1;
+            valueSerializer.writeNumber(value_width_value_1);
+        }
+        else if (value_width_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_width_value_2 = value_width_value.value2;
+            Resource_serializer::write(valueSerializer, value_width_value_2);
+        }
     }
-    const auto value__iconStyle = value._iconStyle;
-    Ark_Int32 value__iconStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value__iconStyle_type = runtimeType(value__iconStyle);
-    valueSerializer.writeInt8(value__iconStyle_type);
-    if ((value__iconStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__iconStyle_value = value__iconStyle.value;
-        TabBarIconStyle_serializer::write(valueSerializer, value__iconStyle_value);
+    const auto value_arrowPointPosition = value.arrowPointPosition;
+    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
+    valueSerializer.writeInt8(value_arrowPointPosition_type);
+    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
+        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
     }
-}
-inline Ark_BottomTabBarStyle BottomTabBarStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_BottomTabBarStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto _icon_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceStr_TabBarSymbol _icon_buf = {};
-    _icon_buf.tag = _icon_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_icon_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _icon_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceStr_TabBarSymbol _icon_buf_ = {};
-        _icon_buf_.selector = _icon_buf__selector;
-        if (_icon_buf__selector == 0) {
-            _icon_buf_.selector = 0;
-            const Ark_Int8 _icon_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceStr _icon_buf__u = {};
-            _icon_buf__u.selector = _icon_buf__u_selector;
-            if (_icon_buf__u_selector == 0) {
-                _icon_buf__u.selector = 0;
-                _icon_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (_icon_buf__u_selector == 1) {
-                _icon_buf__u.selector = 1;
-                _icon_buf__u.value1 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for _icon_buf__u has to be chosen through deserialisation.");
-            }
-            _icon_buf_.value0 = static_cast<Ark_ResourceStr>(_icon_buf__u);
+    const auto value_arrowWidth = value.arrowWidth;
+    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowWidth_type = runtimeType(value_arrowWidth);
+    valueSerializer.writeInt8(value_arrowWidth_type);
+    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowWidth_value = value_arrowWidth.value;
+        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowWidth_value_type = value_arrowWidth_value.selector;
+        if (value_arrowWidth_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
+            valueSerializer.writeString(value_arrowWidth_value_0);
         }
-        else if (_icon_buf__selector == 1) {
-            _icon_buf_.selector = 1;
-            _icon_buf_.value1 = static_cast<Ark_TabBarSymbol>(TabBarSymbol_serializer::read(valueDeserializer));
+        else if (value_arrowWidth_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
+            valueSerializer.writeNumber(value_arrowWidth_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for _icon_buf_ has to be chosen through deserialisation.");
+        else if (value_arrowWidth_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
         }
-        _icon_buf.value = static_cast<Ark_Union_ResourceStr_TabBarSymbol>(_icon_buf_);
     }
-    value._icon = _icon_buf;
-    const auto _text_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceStr _text_buf = {};
-    _text_buf.tag = _text_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_text_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _text_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceStr _text_buf_ = {};
-        _text_buf_.selector = _text_buf__selector;
-        if (_text_buf__selector == 0) {
-            _text_buf_.selector = 0;
-            _text_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+    const auto value_arrowHeight = value.arrowHeight;
+    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowHeight_type = runtimeType(value_arrowHeight);
+    valueSerializer.writeInt8(value_arrowHeight_type);
+    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowHeight_value = value_arrowHeight.value;
+        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowHeight_value_type = value_arrowHeight_value.selector;
+        if (value_arrowHeight_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
+            valueSerializer.writeString(value_arrowHeight_value_0);
         }
-        else if (_text_buf__selector == 1) {
-            _text_buf_.selector = 1;
-            _text_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (value_arrowHeight_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
+            valueSerializer.writeNumber(value_arrowHeight_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for _text_buf_ has to be chosen through deserialisation.");
+        else if (value_arrowHeight_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
         }
-        _text_buf.value = static_cast<Ark_ResourceStr>(_text_buf_);
-    }
-    value._text = _text_buf;
-    const auto _labelStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TabBarLabelStyle _labelStyle_buf = {};
-    _labelStyle_buf.tag = _labelStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_labelStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _labelStyle_buf.value = TabBarLabelStyle_serializer::read(valueDeserializer);
     }
-    value._labelStyle = _labelStyle_buf;
-    const auto _padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Padding_Dimension_LocalizedPadding _padding_buf = {};
-    _padding_buf.tag = _padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _padding_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Padding_Dimension_LocalizedPadding _padding_buf_ = {};
-        _padding_buf_.selector = _padding_buf__selector;
-        if (_padding_buf__selector == 0) {
-            _padding_buf_.selector = 0;
-            _padding_buf_.value0 = Padding_serializer::read(valueDeserializer);
-        }
-        else if (_padding_buf__selector == 1) {
-            _padding_buf_.selector = 1;
-            const Ark_Int8 _padding_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension _padding_buf__u = {};
-            _padding_buf__u.selector = _padding_buf__u_selector;
-            if (_padding_buf__u_selector == 0) {
-                _padding_buf__u.selector = 0;
-                _padding_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (_padding_buf__u_selector == 1) {
-                _padding_buf__u.selector = 1;
-                _padding_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (_padding_buf__u_selector == 2) {
-                _padding_buf__u.selector = 2;
-                _padding_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for _padding_buf__u has to be chosen through deserialisation.");
-            }
-            _padding_buf_.value1 = static_cast<Ark_Dimension>(_padding_buf__u);
+    const auto value_radius = value.radius;
+    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_radius_type = runtimeType(value_radius);
+    valueSerializer.writeInt8(value_radius_type);
+    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_radius_value = value_radius.value;
+        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_radius_value_type = value_radius_value.selector;
+        if (value_radius_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_radius_value_0 = value_radius_value.value0;
+            valueSerializer.writeString(value_radius_value_0);
         }
-        else if (_padding_buf__selector == 2) {
-            _padding_buf_.selector = 2;
-            _padding_buf_.value2 = LocalizedPadding_serializer::read(valueDeserializer);
+        else if (value_radius_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_radius_value_1 = value_radius_value.value1;
+            valueSerializer.writeNumber(value_radius_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for _padding_buf_ has to be chosen through deserialisation.");
+        else if (value_radius_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_radius_value_2 = value_radius_value.value2;
+            Resource_serializer::write(valueSerializer, value_radius_value_2);
         }
-        _padding_buf.value = static_cast<Ark_Union_Padding_Dimension_LocalizedPadding>(_padding_buf_);
-    }
-    value._padding = _padding_buf;
-    const auto _layoutMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_LayoutMode _layoutMode_buf = {};
-    _layoutMode_buf.tag = _layoutMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_layoutMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _layoutMode_buf.value = static_cast<Ark_LayoutMode>(valueDeserializer.readInt32());
     }
-    value._layoutMode = _layoutMode_buf;
-    const auto _verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VerticalAlign _verticalAlign_buf = {};
-    _verticalAlign_buf.tag = _verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _verticalAlign_buf.value = static_cast<Ark_VerticalAlign>(valueDeserializer.readInt32());
-    }
-    value._verticalAlign = _verticalAlign_buf;
-    const auto _symmetricExtensible_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean _symmetricExtensible_buf = {};
-    _symmetricExtensible_buf.tag = _symmetricExtensible_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_symmetricExtensible_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _symmetricExtensible_buf.value = valueDeserializer.readBoolean();
-    }
-    value._symmetricExtensible = _symmetricExtensible_buf;
-    const auto _id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String _id_buf = {};
-    _id_buf.tag = _id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
-    }
-    value._id = _id_buf;
-    const auto _iconStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TabBarIconStyle _iconStyle_buf = {};
-    _iconStyle_buf.tag = _iconStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_iconStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _iconStyle_buf.value = TabBarIconStyle_serializer::read(valueDeserializer);
-    }
-    value._iconStyle = _iconStyle_buf;
-    return value;
-}
-inline void CalendarDialogOptions_serializer::write(SerializerBase& buffer, Ark_CalendarDialogOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_hintRadius = value.hintRadius;
-    Ark_Int32 value_hintRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hintRadius_type = runtimeType(value_hintRadius);
-    valueSerializer.writeInt8(value_hintRadius_type);
-    if ((value_hintRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hintRadius_value = value_hintRadius.value;
-        Ark_Int32 value_hintRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_hintRadius_value_type = value_hintRadius_value.selector;
-        if (value_hintRadius_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_hintRadius_value_0 = value_hintRadius_value.value0;
-            valueSerializer.writeNumber(value_hintRadius_value_0);
-        }
-        else if (value_hintRadius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_hintRadius_value_1 = value_hintRadius_value.value1;
-            Resource_serializer::write(valueSerializer, value_hintRadius_value_1);
-        }
-    }
-    const auto value_selected = value.selected;
-    Ark_Int32 value_selected_type = INTEROP_RUNTIME_UNDEFINED;
-    value_selected_type = runtimeType(value_selected);
-    valueSerializer.writeInt8(value_selected_type);
-    if ((value_selected_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_selected_value = value_selected.value;
-        valueSerializer.writeInt64(value_selected_value);
-    }
-    const auto value_start = value.start;
-    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
-    value_start_type = runtimeType(value_start);
-    valueSerializer.writeInt8(value_start_type);
-    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_start_value = value_start.value;
-        valueSerializer.writeInt64(value_start_value);
-    }
-    const auto value_end = value.end;
-    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
-    value_end_type = runtimeType(value_end);
-    valueSerializer.writeInt8(value_end_type);
-    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_end_value = value_end.value;
-        valueSerializer.writeInt64(value_end_value);
-    }
-    const auto value_disabledDateRange = value.disabledDateRange;
-    Ark_Int32 value_disabledDateRange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_disabledDateRange_type = runtimeType(value_disabledDateRange);
-    valueSerializer.writeInt8(value_disabledDateRange_type);
-    if ((value_disabledDateRange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_disabledDateRange_value = value_disabledDateRange.value;
-        valueSerializer.writeInt32(value_disabledDateRange_value.length);
-        for (int value_disabledDateRange_value_counter_i = 0; value_disabledDateRange_value_counter_i < value_disabledDateRange_value.length; value_disabledDateRange_value_counter_i++) {
-            const Ark_DateRange value_disabledDateRange_value_element = value_disabledDateRange_value.array[value_disabledDateRange_value_counter_i];
-            DateRange_serializer::write(valueSerializer, value_disabledDateRange_value_element);
-        }
-    }
-    const auto value_onAccept = value.onAccept;
-    Ark_Int32 value_onAccept_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onAccept_type = runtimeType(value_onAccept);
-    valueSerializer.writeInt8(value_onAccept_type);
-    if ((value_onAccept_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onAccept_value = value_onAccept.value;
-        valueSerializer.writeCallbackResource(value_onAccept_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.callSync));
-    }
-    const auto value_onCancel = value.onCancel;
-    Ark_Int32 value_onCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onCancel_type = runtimeType(value_onCancel);
-    valueSerializer.writeInt8(value_onCancel_type);
-    if ((value_onCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onCancel_value = value_onCancel.value;
-        valueSerializer.writeCallbackResource(value_onCancel_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.callSync));
-    }
-    const auto value_onChange = value.onChange;
-    Ark_Int32 value_onChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onChange_type = runtimeType(value_onChange);
-    valueSerializer.writeInt8(value_onChange_type);
-    if ((value_onChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onChange_value = value_onChange.value;
-        valueSerializer.writeCallbackResource(value_onChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.callSync));
-    }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_shadow_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
-        }
-        else if (value_backgroundColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
-        }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
     }
     const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
@@ -110920,95 +112471,41 @@ inline void CalendarDialogOptions_serializer::write(SerializerBase& buffer, Ark_
         const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
         valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
     }
-    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
-    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
-    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
-    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
-        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
-    }
-    const auto value_backgroundEffect = value.backgroundEffect;
-    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
-    valueSerializer.writeInt8(value_backgroundEffect_type);
-    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundEffect_value = value_backgroundEffect.value;
-        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
-    }
-    const auto value_acceptButtonStyle = value.acceptButtonStyle;
-    Ark_Int32 value_acceptButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_acceptButtonStyle_type = runtimeType(value_acceptButtonStyle);
-    valueSerializer.writeInt8(value_acceptButtonStyle_type);
-    if ((value_acceptButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_acceptButtonStyle_value = value_acceptButtonStyle.value;
-        PickerDialogButtonStyle_serializer::write(valueSerializer, value_acceptButtonStyle_value);
-    }
-    const auto value_cancelButtonStyle = value.cancelButtonStyle;
-    Ark_Int32 value_cancelButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_cancelButtonStyle_type = runtimeType(value_cancelButtonStyle);
-    valueSerializer.writeInt8(value_cancelButtonStyle_type);
-    if ((value_cancelButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_cancelButtonStyle_value = value_cancelButtonStyle.value;
-        PickerDialogButtonStyle_serializer::write(valueSerializer, value_cancelButtonStyle_value);
-    }
-    const auto value_onDidAppear = value.onDidAppear;
-    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidAppear_type = runtimeType(value_onDidAppear);
-    valueSerializer.writeInt8(value_onDidAppear_type);
-    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidAppear_value = value_onDidAppear.value;
-        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
-    }
-    const auto value_onDidDisappear = value.onDidDisappear;
-    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
-    valueSerializer.writeInt8(value_onDidDisappear_type);
-    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidDisappear_value = value_onDidDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
-    }
-    const auto value_onWillAppear = value.onWillAppear;
-    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillAppear_type = runtimeType(value_onWillAppear);
-    valueSerializer.writeInt8(value_onWillAppear_type);
-    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillAppear_value = value_onWillAppear.value;
-        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    const auto value_focusable = value.focusable;
+    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
+    value_focusable_type = runtimeType(value_focusable);
+    valueSerializer.writeInt8(value_focusable_type);
+    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_focusable_value = value_focusable.value;
+        valueSerializer.writeBoolean(value_focusable_value);
     }
-    const auto value_onWillDisappear = value.onWillDisappear;
-    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
-    valueSerializer.writeInt8(value_onWillDisappear_type);
-    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDisappear_value = value_onWillDisappear.value;
-        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    const auto value_transition = value.transition;
+    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_transition_type = runtimeType(value_transition);
+    valueSerializer.writeInt8(value_transition_type);
+    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_transition_value = value_transition.value;
+        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
     }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
+        if (value_onWillDismiss_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
+            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
         }
-        else if (value_shadow_value_type == 1) {
+        else if (value_onWillDismiss_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
+            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
         }
     }
     const auto value_enableHoverMode = value.enableHoverMode;
@@ -111019,214 +112516,283 @@ inline void CalendarDialogOptions_serializer::write(SerializerBase& buffer, Ark_
         const auto value_enableHoverMode_value = value_enableHoverMode.value;
         valueSerializer.writeBoolean(value_enableHoverMode_value);
     }
-    const auto value_hoverModeArea = value.hoverModeArea;
-    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
-    valueSerializer.writeInt8(value_hoverModeArea_type);
-    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hoverModeArea_value = value_hoverModeArea.value;
-        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
-    }
-    const auto value_markToday = value.markToday;
-    Ark_Int32 value_markToday_type = INTEROP_RUNTIME_UNDEFINED;
-    value_markToday_type = runtimeType(value_markToday);
-    valueSerializer.writeInt8(value_markToday_type);
-    if ((value_markToday_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_markToday_value = value_markToday.value;
-        valueSerializer.writeBoolean(value_markToday_value);
+    const auto value_followTransformOfTarget = value.followTransformOfTarget;
+    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
+    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
+    valueSerializer.writeInt8(value_followTransformOfTarget_type);
+    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
+        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
     }
 }
-inline Ark_CalendarDialogOptions CalendarDialogOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_PopupCommonOptions PopupCommonOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_CalendarDialogOptions value = {};
+    Ark_PopupCommonOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto hintRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_Resource hintRadius_buf = {};
-    hintRadius_buf.tag = hintRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hintRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Placement placement_buf = {};
+    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 hintRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_Resource hintRadius_buf_ = {};
-        hintRadius_buf_.selector = hintRadius_buf__selector;
-        if (hintRadius_buf__selector == 0) {
-            hintRadius_buf_.selector = 0;
-            hintRadius_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
+    }
+    value.placement = placement_buf;
+    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor popupColor_buf = {};
+    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor popupColor_buf_ = {};
+        popupColor_buf_.selector = popupColor_buf__selector;
+        if (popupColor_buf__selector == 0) {
+            popupColor_buf_.selector = 0;
+            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (hintRadius_buf__selector == 1) {
-            hintRadius_buf_.selector = 1;
-            hintRadius_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (popupColor_buf__selector == 1) {
+            popupColor_buf_.selector = 1;
+            popupColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (popupColor_buf__selector == 2) {
+            popupColor_buf_.selector = 2;
+            popupColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (popupColor_buf__selector == 3) {
+            popupColor_buf_.selector = 3;
+            popupColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for hintRadius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
         }
-        hintRadius_buf.value = static_cast<Ark_Union_Number_Resource>(hintRadius_buf_);
+        popupColor_buf.value = static_cast<Ark_ResourceColor>(popupColor_buf_);
     }
-    value.hintRadius = hintRadius_buf;
-    const auto selected_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Date selected_buf = {};
-    selected_buf.tag = selected_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((selected_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.popupColor = popupColor_buf;
+    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableArrow_buf = {};
+    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        selected_buf.value = valueDeserializer.readInt64();
+        enableArrow_buf.value = valueDeserializer.readBoolean();
     }
-    value.selected = selected_buf;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Date start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.enableArrow = enableArrow_buf;
+    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean autoCancel_buf = {};
+    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        start_buf.value = valueDeserializer.readInt64();
+        autoCancel_buf.value = valueDeserializer.readBoolean();
     }
-    value.start = start_buf;
-    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Date end_buf = {};
-    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.autoCancel = autoCancel_buf;
+    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupStateChangeCallback onStateChange_buf = {};
+    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        end_buf.value = valueDeserializer.readInt64();
+        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
     }
-    value.end = end_buf;
-    const auto disabledDateRange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Array_DateRange disabledDateRange_buf = {};
-    disabledDateRange_buf.tag = disabledDateRange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((disabledDateRange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onStateChange = onStateChange_buf;
+    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length arrowOffset_buf = {};
+    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int32 disabledDateRange_buf__length = valueDeserializer.readInt32();
-        Array_DateRange disabledDateRange_buf_ = {};
-        valueDeserializer.resizeArray<std::decay<decltype(disabledDateRange_buf_)>::type,
-        std::decay<decltype(*disabledDateRange_buf_.array)>::type>(&disabledDateRange_buf_, disabledDateRange_buf__length);
-        for (int disabledDateRange_buf__i = 0; disabledDateRange_buf__i < disabledDateRange_buf__length; disabledDateRange_buf__i++) {
-            disabledDateRange_buf_.array[disabledDateRange_buf__i] = DateRange_serializer::read(valueDeserializer);
+        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
+        Ark_Length arrowOffset_buf_ = {};
+        arrowOffset_buf_.selector = arrowOffset_buf__selector;
+        if (arrowOffset_buf__selector == 0) {
+            arrowOffset_buf_.selector = 0;
+            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        disabledDateRange_buf.value = disabledDateRange_buf_;
-    }
-    value.disabledDateRange = disabledDateRange_buf;
-    const auto onAccept_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Date_Void onAccept_buf = {};
-    onAccept_buf.tag = onAccept_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAccept_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onAccept_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Date_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Date_Void))))};
+        else if (arrowOffset_buf__selector == 1) {
+            arrowOffset_buf_.selector = 1;
+            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowOffset_buf__selector == 2) {
+            arrowOffset_buf_.selector = 2;
+            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
+        }
+        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
     }
-    value.onAccept = onAccept_buf;
-    const auto onCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VoidCallback onCancel_buf = {};
-    onCancel_buf.tag = onCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowOffset = arrowOffset_buf;
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onCancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
     }
-    value.onCancel = onCancel_buf;
-    const auto onChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Date_Void onChange_buf = {};
-    onChange_buf.tag = onChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.showInSubWindow = showInSubWindow_buf;
+    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_PopupMaskType mask_buf = {};
+    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Date_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Date_Void))))};
+        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
+        mask_buf_.selector = mask_buf__selector;
+        if (mask_buf__selector == 0) {
+            mask_buf_.selector = 0;
+            mask_buf_.value0 = valueDeserializer.readBoolean();
+        }
+        else if (mask_buf__selector == 1) {
+            mask_buf_.selector = 1;
+            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
+        }
+        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
     }
-    value.onChange = onChange_buf;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.mask = mask_buf;
+    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length targetSpace_buf = {};
+    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
+        Ark_Length targetSpace_buf_ = {};
+        targetSpace_buf_.selector = targetSpace_buf__selector;
+        if (targetSpace_buf__selector == 0) {
+            targetSpace_buf_.selector = 0;
+            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (targetSpace_buf__selector == 1) {
+            targetSpace_buf_.selector = 1;
+            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (targetSpace_buf__selector == 2) {
+            targetSpace_buf_.selector = 2;
+            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
+        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
     }
-    value.backgroundColor = backgroundColor_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
-    }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
-    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
-    }
-    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
-    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
-    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
-    }
-    value.backgroundEffect = backgroundEffect_buf;
-    const auto acceptButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerDialogButtonStyle acceptButtonStyle_buf = {};
-    acceptButtonStyle_buf.tag = acceptButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((acceptButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.targetSpace = targetSpace_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        acceptButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
+        offset_buf.value = Position_serializer::read(valueDeserializer);
     }
-    value.acceptButtonStyle = acceptButtonStyle_buf;
-    const auto cancelButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerDialogButtonStyle cancelButtonStyle_buf = {};
-    cancelButtonStyle_buf.tag = cancelButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((cancelButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.offset = offset_buf;
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        cancelButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
+        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension width_buf_ = {};
+        width_buf_.selector = width_buf__selector;
+        if (width_buf__selector == 0) {
+            width_buf_.selector = 0;
+            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (width_buf__selector == 2) {
+            width_buf_.selector = 2;
+            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+        }
+        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
     }
-    value.cancelButtonStyle = cancelButtonStyle_buf;
-    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VoidCallback onDidAppear_buf = {};
-    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.width = width_buf;
+    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ArrowPointPosition arrowPointPosition_buf = {};
+    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
+        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
     }
-    value.onDidAppear = onDidAppear_buf;
-    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VoidCallback onDidDisappear_buf = {};
-    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowPointPosition = arrowPointPosition_buf;
+    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowWidth_buf = {};
+    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
+        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowWidth_buf_ = {};
+        arrowWidth_buf_.selector = arrowWidth_buf__selector;
+        if (arrowWidth_buf__selector == 0) {
+            arrowWidth_buf_.selector = 0;
+            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowWidth_buf__selector == 1) {
+            arrowWidth_buf_.selector = 1;
+            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowWidth_buf__selector == 2) {
+            arrowWidth_buf_.selector = 2;
+            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
+        }
+        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
     }
-    value.onDidDisappear = onDidDisappear_buf;
-    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VoidCallback onWillAppear_buf = {};
-    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowWidth = arrowWidth_buf;
+    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowHeight_buf = {};
+    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
+        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowHeight_buf_ = {};
+        arrowHeight_buf_.selector = arrowHeight_buf__selector;
+        if (arrowHeight_buf__selector == 0) {
+            arrowHeight_buf_.selector = 0;
+            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowHeight_buf__selector == 1) {
+            arrowHeight_buf_.selector = 1;
+            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowHeight_buf__selector == 2) {
+            arrowHeight_buf_.selector = 2;
+            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
+        }
+        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
     }
-    value.onWillAppear = onWillAppear_buf;
-    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_VoidCallback onWillDisappear_buf = {};
-    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.arrowHeight = arrowHeight_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (radius_buf__selector == 2) {
+            radius_buf_.selector = 2;
+            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+        }
+        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
     }
-    value.onWillDisappear = onWillDisappear_buf;
+    value.radius = radius_buf;
     const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
     shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -111249,6 +112815,52 @@ inline Ark_CalendarDialogOptions CalendarDialogOptions_serializer::read(Deserial
         shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
     value.shadow = shadow_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+    }
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean focusable_buf = {};
+    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        focusable_buf.value = valueDeserializer.readBoolean();
+    }
+    value.focusable = focusable_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    }
+    value.transition = transition_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
+        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
+        if (onWillDismiss_buf__selector == 0) {
+            onWillDismiss_buf_.selector = 0;
+            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
+        }
+        else if (onWillDismiss_buf__selector == 1) {
+            onWillDismiss_buf_.selector = 1;
+            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
+        }
+        else {
+            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
+        }
+        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
+    }
+    value.onWillDismiss = onWillDismiss_buf;
     const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Boolean enableHoverMode_buf = {};
     enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -111257,1555 +112869,2118 @@ inline Ark_CalendarDialogOptions CalendarDialogOptions_serializer::read(Deserial
         enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
     value.enableHoverMode = enableHoverMode_buf;
-    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HoverModeAreaType hoverModeArea_buf = {};
-    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean followTransformOfTarget_buf = {};
+    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
+        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
     }
-    value.hoverModeArea = hoverModeArea_buf;
-    const auto markToday_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean markToday_buf = {};
-    markToday_buf.tag = markToday_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((markToday_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.followTransformOfTarget = followTransformOfTarget_buf;
+    return value;
+}
+inline void PopupMessageOptions_serializer::write(SerializerBase& buffer, Ark_PopupMessageOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_textColor = value.textColor;
+    Ark_Int32 value_textColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textColor_type = runtimeType(value_textColor);
+    valueSerializer.writeInt8(value_textColor_type);
+    if ((value_textColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textColor_value = value_textColor.value;
+        Ark_Int32 value_textColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_textColor_value_type = value_textColor_value.selector;
+        if (value_textColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_textColor_value_0 = value_textColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_textColor_value_0));
+        }
+        else if (value_textColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_textColor_value_1 = value_textColor_value.value1;
+            valueSerializer.writeNumber(value_textColor_value_1);
+        }
+        else if (value_textColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_textColor_value_2 = value_textColor_value.value2;
+            valueSerializer.writeString(value_textColor_value_2);
+        }
+        else if (value_textColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_textColor_value_3 = value_textColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_textColor_value_3);
+        }
+    }
+    const auto value_font = value.font;
+    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
+    value_font_type = runtimeType(value_font);
+    valueSerializer.writeInt8(value_font_type);
+    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_font_value = value_font.value;
+        Font_serializer::write(valueSerializer, value_font_value);
+    }
+}
+inline Ark_PopupMessageOptions PopupMessageOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_PopupMessageOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto textColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor textColor_buf = {};
+    textColor_buf.tag = textColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        markToday_buf.value = valueDeserializer.readBoolean();
+        const Ark_Int8 textColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor textColor_buf_ = {};
+        textColor_buf_.selector = textColor_buf__selector;
+        if (textColor_buf__selector == 0) {
+            textColor_buf_.selector = 0;
+            textColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (textColor_buf__selector == 1) {
+            textColor_buf_.selector = 1;
+            textColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (textColor_buf__selector == 2) {
+            textColor_buf_.selector = 2;
+            textColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (textColor_buf__selector == 3) {
+            textColor_buf_.selector = 3;
+            textColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for textColor_buf_ has to be chosen through deserialisation.");
+        }
+        textColor_buf.value = static_cast<Ark_ResourceColor>(textColor_buf_);
     }
-    value.markToday = markToday_buf;
+    value.textColor = textColor_buf;
+    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font font_buf = {};
+    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        font_buf.value = Font_serializer::read(valueDeserializer);
+    }
+    value.font = font_buf;
     return value;
 }
-inline void ClickEvent_serializer::write(SerializerBase& buffer, Ark_ClickEvent value)
+inline void ResizableOptions_serializer::write(SerializerBase& buffer, Ark_ResizableOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
+    const auto value_slice = value.slice;
+    Ark_Int32 value_slice_type = INTEROP_RUNTIME_UNDEFINED;
+    value_slice_type = runtimeType(value_slice);
+    valueSerializer.writeInt8(value_slice_type);
+    if ((value_slice_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_slice_value = value_slice.value;
+        EdgeWidths_serializer::write(valueSerializer, value_slice_value);
+    }
+    const auto value_lattice = value.lattice;
+    Ark_Int32 value_lattice_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lattice_type = runtimeType(value_lattice);
+    valueSerializer.writeInt8(value_lattice_type);
+    if ((value_lattice_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lattice_value = value_lattice.value;
+        drawing_Lattice_serializer::write(valueSerializer, value_lattice_value);
+    }
 }
-inline Ark_ClickEvent ClickEvent_serializer::read(DeserializerBase& buffer)
+inline Ark_ResizableOptions ResizableOptions_serializer::read(DeserializerBase& buffer)
 {
+    Ark_ResizableOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_ClickEvent>(ptr);
+    const auto slice_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_EdgeWidths slice_buf = {};
+    slice_buf.tag = slice_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((slice_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        slice_buf.value = EdgeWidths_serializer::read(valueDeserializer);
+    }
+    value.slice = slice_buf;
+    const auto lattice_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_drawing_Lattice lattice_buf = {};
+    lattice_buf.tag = lattice_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lattice_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        lattice_buf.value = static_cast<Ark_drawing_Lattice>(drawing_Lattice_serializer::read(valueDeserializer));
+    }
+    value.lattice = lattice_buf;
+    return value;
 }
-inline void GridRowOptions_serializer::write(SerializerBase& buffer, Ark_GridRowOptions value)
+inline void RichEditorLayoutStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorLayoutStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_gutter = value.gutter;
-    Ark_Int32 value_gutter_type = INTEROP_RUNTIME_UNDEFINED;
-    value_gutter_type = runtimeType(value_gutter);
-    valueSerializer.writeInt8(value_gutter_type);
-    if ((value_gutter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_gutter_value = value_gutter.value;
-        Ark_Int32 value_gutter_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_gutter_value_type = value_gutter_value.selector;
-        if ((value_gutter_value_type == 0) || (value_gutter_value_type == 0) || (value_gutter_value_type == 0)) {
+    const auto value_margin = value.margin;
+    Ark_Int32 value_margin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_margin_type = runtimeType(value_margin);
+    valueSerializer.writeInt8(value_margin_type);
+    if ((value_margin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_margin_value = value_margin.value;
+        Ark_Int32 value_margin_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_margin_value_type = value_margin_value.selector;
+        if ((value_margin_value_type == 0) || (value_margin_value_type == 0) || (value_margin_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_gutter_value_0 = value_gutter_value.value0;
-            Ark_Int32 value_gutter_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_gutter_value_0_type = value_gutter_value_0.selector;
-            if (value_gutter_value_0_type == 0) {
+            const auto value_margin_value_0 = value_margin_value.value0;
+            Ark_Int32 value_margin_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_margin_value_0_type = value_margin_value_0.selector;
+            if (value_margin_value_0_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value_gutter_value_0_0 = value_gutter_value_0.value0;
-                valueSerializer.writeString(value_gutter_value_0_0);
+                const auto value_margin_value_0_0 = value_margin_value_0.value0;
+                valueSerializer.writeString(value_margin_value_0_0);
             }
-            else if (value_gutter_value_0_type == 1) {
+            else if (value_margin_value_0_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value_gutter_value_0_1 = value_gutter_value_0.value1;
-                valueSerializer.writeNumber(value_gutter_value_0_1);
+                const auto value_margin_value_0_1 = value_margin_value_0.value1;
+                valueSerializer.writeNumber(value_margin_value_0_1);
             }
-            else if (value_gutter_value_0_type == 2) {
+            else if (value_margin_value_0_type == 2) {
                 valueSerializer.writeInt8(2);
-                const auto value_gutter_value_0_2 = value_gutter_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_gutter_value_0_2);
+                const auto value_margin_value_0_2 = value_margin_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_margin_value_0_2);
             }
         }
-        else if (value_gutter_value_type == 1) {
+        else if (value_margin_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_gutter_value_1 = value_gutter_value.value1;
-            GutterOption_serializer::write(valueSerializer, value_gutter_value_1);
+            const auto value_margin_value_1 = value_margin_value.value1;
+            Padding_serializer::write(valueSerializer, value_margin_value_1);
         }
     }
-    const auto value_columns = value.columns;
-    Ark_Int32 value_columns_type = INTEROP_RUNTIME_UNDEFINED;
-    value_columns_type = runtimeType(value_columns);
-    valueSerializer.writeInt8(value_columns_type);
-    if ((value_columns_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_columns_value = value_columns.value;
-        Ark_Int32 value_columns_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_columns_value_type = value_columns_value.selector;
-        if (value_columns_value_type == 0) {
+    const auto value_borderRadius = value.borderRadius;
+    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderRadius_type = runtimeType(value_borderRadius);
+    valueSerializer.writeInt8(value_borderRadius_type);
+    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderRadius_value = value_borderRadius.value;
+        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderRadius_value_type = value_borderRadius_value.selector;
+        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_columns_value_0 = value_columns_value.value0;
-            valueSerializer.writeNumber(value_columns_value_0);
+            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
+            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
+            if (value_borderRadius_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
+                valueSerializer.writeString(value_borderRadius_value_0_0);
+            }
+            else if (value_borderRadius_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
+                valueSerializer.writeNumber(value_borderRadius_value_0_1);
+            }
+            else if (value_borderRadius_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
+            }
         }
-        else if (value_columns_value_type == 1) {
+        else if (value_borderRadius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_columns_value_1 = value_columns_value.value1;
-            GridRowColumnOption_serializer::write(valueSerializer, value_columns_value_1);
+            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
         }
     }
-    const auto value_breakpoints = value.breakpoints;
-    Ark_Int32 value_breakpoints_type = INTEROP_RUNTIME_UNDEFINED;
-    value_breakpoints_type = runtimeType(value_breakpoints);
-    valueSerializer.writeInt8(value_breakpoints_type);
-    if ((value_breakpoints_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_breakpoints_value = value_breakpoints.value;
-        BreakPoints_serializer::write(valueSerializer, value_breakpoints_value);
-    }
-    const auto value_direction = value.direction;
-    Ark_Int32 value_direction_type = INTEROP_RUNTIME_UNDEFINED;
-    value_direction_type = runtimeType(value_direction);
-    valueSerializer.writeInt8(value_direction_type);
-    if ((value_direction_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_direction_value = value_direction.value;
-        valueSerializer.writeInt32(static_cast<Ark_GridRowDirection>(value_direction_value));
-    }
 }
-inline Ark_GridRowOptions GridRowOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_RichEditorLayoutStyle RichEditorLayoutStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_GridRowOptions value = {};
+    Ark_RichEditorLayoutStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto gutter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_GutterOption gutter_buf = {};
-    gutter_buf.tag = gutter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((gutter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto margin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_Margin margin_buf = {};
+    margin_buf.tag = margin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((margin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 gutter_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_GutterOption gutter_buf_ = {};
-        gutter_buf_.selector = gutter_buf__selector;
-        if (gutter_buf__selector == 0) {
-            gutter_buf_.selector = 0;
-            const Ark_Int8 gutter_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length gutter_buf__u = {};
-            gutter_buf__u.selector = gutter_buf__u_selector;
-            if (gutter_buf__u_selector == 0) {
-                gutter_buf__u.selector = 0;
-                gutter_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 margin_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_Margin margin_buf_ = {};
+        margin_buf_.selector = margin_buf__selector;
+        if (margin_buf__selector == 0) {
+            margin_buf_.selector = 0;
+            const Ark_Int8 margin_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension margin_buf__u = {};
+            margin_buf__u.selector = margin_buf__u_selector;
+            if (margin_buf__u_selector == 0) {
+                margin_buf__u.selector = 0;
+                margin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (gutter_buf__u_selector == 1) {
-                gutter_buf__u.selector = 1;
-                gutter_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            else if (margin_buf__u_selector == 1) {
+                margin_buf__u.selector = 1;
+                margin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
             }
-            else if (gutter_buf__u_selector == 2) {
-                gutter_buf__u.selector = 2;
-                gutter_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            else if (margin_buf__u_selector == 2) {
+                margin_buf__u.selector = 2;
+                margin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for gutter_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for margin_buf__u has to be chosen through deserialisation.");
             }
-            gutter_buf_.value0 = static_cast<Ark_Length>(gutter_buf__u);
+            margin_buf_.value0 = static_cast<Ark_Dimension>(margin_buf__u);
         }
-        else if (gutter_buf__selector == 1) {
-            gutter_buf_.selector = 1;
-            gutter_buf_.value1 = GutterOption_serializer::read(valueDeserializer);
+        else if (margin_buf__selector == 1) {
+            margin_buf_.selector = 1;
+            margin_buf_.value1 = Padding_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for gutter_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for margin_buf_ has to be chosen through deserialisation.");
         }
-        gutter_buf.value = static_cast<Ark_Union_Length_GutterOption>(gutter_buf_);
+        margin_buf.value = static_cast<Ark_Union_Dimension_Margin>(margin_buf_);
     }
-    value.gutter = gutter_buf;
-    const auto columns_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_GridRowColumnOption columns_buf = {};
-    columns_buf.tag = columns_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((columns_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.margin = margin_buf;
+    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_BorderRadiuses borderRadius_buf = {};
+    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 columns_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_GridRowColumnOption columns_buf_ = {};
-        columns_buf_.selector = columns_buf__selector;
-        if (columns_buf__selector == 0) {
-            columns_buf_.selector = 0;
-            columns_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_BorderRadiuses borderRadius_buf_ = {};
+        borderRadius_buf_.selector = borderRadius_buf__selector;
+        if (borderRadius_buf__selector == 0) {
+            borderRadius_buf_.selector = 0;
+            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension borderRadius_buf__u = {};
+            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
+            if (borderRadius_buf__u_selector == 0) {
+                borderRadius_buf__u.selector = 0;
+                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderRadius_buf__u_selector == 1) {
+                borderRadius_buf__u.selector = 1;
+                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderRadius_buf__u_selector == 2) {
+                borderRadius_buf__u.selector = 2;
+                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
+            }
+            borderRadius_buf_.value0 = static_cast<Ark_Dimension>(borderRadius_buf__u);
         }
-        else if (columns_buf__selector == 1) {
-            columns_buf_.selector = 1;
-            columns_buf_.value1 = GridRowColumnOption_serializer::read(valueDeserializer);
+        else if (borderRadius_buf__selector == 1) {
+            borderRadius_buf_.selector = 1;
+            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for columns_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
         }
-        columns_buf.value = static_cast<Ark_Union_Number_GridRowColumnOption>(columns_buf_);
-    }
-    value.columns = columns_buf;
-    const auto breakpoints_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BreakPoints breakpoints_buf = {};
-    breakpoints_buf.tag = breakpoints_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((breakpoints_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        breakpoints_buf.value = BreakPoints_serializer::read(valueDeserializer);
-    }
-    value.breakpoints = breakpoints_buf;
-    const auto direction_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_GridRowDirection direction_buf = {};
-    direction_buf.tag = direction_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((direction_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        direction_buf.value = static_cast<Ark_GridRowDirection>(valueDeserializer.readInt32());
+        borderRadius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(borderRadius_buf_);
     }
-    value.direction = direction_buf;
+    value.borderRadius = borderRadius_buf;
     return value;
 }
-inline void ImageAttachment_serializer::write(SerializerBase& buffer, Ark_ImageAttachment value)
-{
-    SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
-}
-inline Ark_ImageAttachment ImageAttachment_serializer::read(DeserializerBase& buffer)
-{
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_ImageAttachment>(ptr);
-}
-inline void ImageAttachmentInterface_serializer::write(SerializerBase& buffer, Ark_ImageAttachmentInterface value)
+inline void RichEditorParagraphStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_value = value.value;
-    image_PixelMap_serializer::write(valueSerializer, value_value);
-    const auto value_size = value.size;
-    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
-    value_size_type = runtimeType(value_size);
-    valueSerializer.writeInt8(value_size_type);
-    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_size_value = value_size.value;
-        SizeOptions_serializer::write(valueSerializer, value_size_value);
-    }
-    const auto value_verticalAlign = value.verticalAlign;
-    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value_verticalAlign_type = runtimeType(value_verticalAlign);
-    valueSerializer.writeInt8(value_verticalAlign_type);
-    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_verticalAlign_value = value_verticalAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
-    }
-    const auto value_objectFit = value.objectFit;
-    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
-    value_objectFit_type = runtimeType(value_objectFit);
-    valueSerializer.writeInt8(value_objectFit_type);
-    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_objectFit_value = value_objectFit.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
-    }
-    const auto value_layoutStyle = value.layoutStyle;
-    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutStyle_type = runtimeType(value_layoutStyle);
-    valueSerializer.writeInt8(value_layoutStyle_type);
-    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutStyle_value = value_layoutStyle.value;
-        ImageAttachmentLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
+    const auto value_textAlign = value.textAlign;
+    Ark_Int32 value_textAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textAlign_type = runtimeType(value_textAlign);
+    valueSerializer.writeInt8(value_textAlign_type);
+    if ((value_textAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textAlign_value = value_textAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextAlign>(value_textAlign_value));
     }
-    const auto value_colorFilter = value.colorFilter;
-    Ark_Int32 value_colorFilter_type = INTEROP_RUNTIME_UNDEFINED;
-    value_colorFilter_type = runtimeType(value_colorFilter);
-    valueSerializer.writeInt8(value_colorFilter_type);
-    if ((value_colorFilter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_colorFilter_value = value_colorFilter.value;
-        Ark_Int32 value_colorFilter_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_colorFilter_value_type = value_colorFilter_value.selector;
-        if (value_colorFilter_value_type == 0) {
+    const auto value_leadingMargin = value.leadingMargin;
+    Ark_Int32 value_leadingMargin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_leadingMargin_type = runtimeType(value_leadingMargin);
+    valueSerializer.writeInt8(value_leadingMargin_type);
+    if ((value_leadingMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_leadingMargin_value = value_leadingMargin.value;
+        Ark_Int32 value_leadingMargin_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_leadingMargin_value_type = value_leadingMargin_value.selector;
+        if ((value_leadingMargin_value_type == 0) || (value_leadingMargin_value_type == 0) || (value_leadingMargin_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_colorFilter_value_0 = value_colorFilter_value.value0;
-            ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_0);
+            const auto value_leadingMargin_value_0 = value_leadingMargin_value.value0;
+            Ark_Int32 value_leadingMargin_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_leadingMargin_value_0_type = value_leadingMargin_value_0.selector;
+            if (value_leadingMargin_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_leadingMargin_value_0_0 = value_leadingMargin_value_0.value0;
+                valueSerializer.writeString(value_leadingMargin_value_0_0);
+            }
+            else if (value_leadingMargin_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_leadingMargin_value_0_1 = value_leadingMargin_value_0.value1;
+                valueSerializer.writeNumber(value_leadingMargin_value_0_1);
+            }
+            else if (value_leadingMargin_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_leadingMargin_value_0_2 = value_leadingMargin_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_leadingMargin_value_0_2);
+            }
         }
-        else if (value_colorFilter_value_type == 1) {
+        else if (value_leadingMargin_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_colorFilter_value_1 = value_colorFilter_value.value1;
-            drawing_ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_1);
+            const auto value_leadingMargin_value_1 = value_leadingMargin_value.value1;
+            LeadingMarginPlaceholder_serializer::write(valueSerializer, value_leadingMargin_value_1);
         }
     }
+    const auto value_wordBreak = value.wordBreak;
+    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
+    value_wordBreak_type = runtimeType(value_wordBreak);
+    valueSerializer.writeInt8(value_wordBreak_type);
+    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_wordBreak_value = value_wordBreak.value;
+        valueSerializer.writeInt32(static_cast<Ark_WordBreak>(value_wordBreak_value));
+    }
+    const auto value_lineBreakStrategy = value.lineBreakStrategy;
+    Ark_Int32 value_lineBreakStrategy_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lineBreakStrategy_type = runtimeType(value_lineBreakStrategy);
+    valueSerializer.writeInt8(value_lineBreakStrategy_type);
+    if ((value_lineBreakStrategy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lineBreakStrategy_value = value_lineBreakStrategy.value;
+        valueSerializer.writeInt32(static_cast<Ark_LineBreakStrategy>(value_lineBreakStrategy_value));
+    }
+    const auto value_paragraphSpacing = value.paragraphSpacing;
+    Ark_Int32 value_paragraphSpacing_type = INTEROP_RUNTIME_UNDEFINED;
+    value_paragraphSpacing_type = runtimeType(value_paragraphSpacing);
+    valueSerializer.writeInt8(value_paragraphSpacing_type);
+    if ((value_paragraphSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_paragraphSpacing_value = value_paragraphSpacing.value;
+        valueSerializer.writeNumber(value_paragraphSpacing_value);
+    }
 }
-inline Ark_ImageAttachmentInterface ImageAttachmentInterface_serializer::read(DeserializerBase& buffer)
+inline Ark_RichEditorParagraphStyle RichEditorParagraphStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_ImageAttachmentInterface value = {};
+    Ark_RichEditorParagraphStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.value = static_cast<Ark_image_PixelMap>(image_PixelMap_serializer::read(valueDeserializer));
-    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SizeOptions size_buf = {};
-    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto textAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextAlign textAlign_buf = {};
+    textAlign_buf.tag = textAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        size_buf.value = SizeOptions_serializer::read(valueDeserializer);
+        textAlign_buf.value = static_cast<Ark_TextAlign>(valueDeserializer.readInt32());
     }
-    value.size = size_buf;
-    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageSpanAlignment verticalAlign_buf = {};
-    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.textAlign = textAlign_buf;
+    const auto leadingMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_LeadingMarginPlaceholder leadingMargin_buf = {};
+    leadingMargin_buf.tag = leadingMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((leadingMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
+        const Ark_Int8 leadingMargin_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_LeadingMarginPlaceholder leadingMargin_buf_ = {};
+        leadingMargin_buf_.selector = leadingMargin_buf__selector;
+        if (leadingMargin_buf__selector == 0) {
+            leadingMargin_buf_.selector = 0;
+            const Ark_Int8 leadingMargin_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension leadingMargin_buf__u = {};
+            leadingMargin_buf__u.selector = leadingMargin_buf__u_selector;
+            if (leadingMargin_buf__u_selector == 0) {
+                leadingMargin_buf__u.selector = 0;
+                leadingMargin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (leadingMargin_buf__u_selector == 1) {
+                leadingMargin_buf__u.selector = 1;
+                leadingMargin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (leadingMargin_buf__u_selector == 2) {
+                leadingMargin_buf__u.selector = 2;
+                leadingMargin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for leadingMargin_buf__u has to be chosen through deserialisation.");
+            }
+            leadingMargin_buf_.value0 = static_cast<Ark_Dimension>(leadingMargin_buf__u);
+        }
+        else if (leadingMargin_buf__selector == 1) {
+            leadingMargin_buf_.selector = 1;
+            leadingMargin_buf_.value1 = LeadingMarginPlaceholder_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for leadingMargin_buf_ has to be chosen through deserialisation.");
+        }
+        leadingMargin_buf.value = static_cast<Ark_Union_Dimension_LeadingMarginPlaceholder>(leadingMargin_buf_);
     }
-    value.verticalAlign = verticalAlign_buf;
-    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageFit objectFit_buf = {};
-    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.leadingMargin = leadingMargin_buf;
+    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_WordBreak wordBreak_buf = {};
+    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
+        wordBreak_buf.value = static_cast<Ark_WordBreak>(valueDeserializer.readInt32());
     }
-    value.objectFit = objectFit_buf;
-    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageAttachmentLayoutStyle layoutStyle_buf = {};
-    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.wordBreak = wordBreak_buf;
+    const auto lineBreakStrategy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LineBreakStrategy lineBreakStrategy_buf = {};
+    lineBreakStrategy_buf.tag = lineBreakStrategy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lineBreakStrategy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        layoutStyle_buf.value = ImageAttachmentLayoutStyle_serializer::read(valueDeserializer);
+        lineBreakStrategy_buf.value = static_cast<Ark_LineBreakStrategy>(valueDeserializer.readInt32());
     }
-    value.layoutStyle = layoutStyle_buf;
-    const auto colorFilter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ColorFilterType colorFilter_buf = {};
-    colorFilter_buf.tag = colorFilter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((colorFilter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.lineBreakStrategy = lineBreakStrategy_buf;
+    const auto paragraphSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number paragraphSpacing_buf = {};
+    paragraphSpacing_buf.tag = paragraphSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((paragraphSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 colorFilter_buf__selector = valueDeserializer.readInt8();
-        Ark_ColorFilterType colorFilter_buf_ = {};
-        colorFilter_buf_.selector = colorFilter_buf__selector;
-        if (colorFilter_buf__selector == 0) {
-            colorFilter_buf_.selector = 0;
-            colorFilter_buf_.value0 = static_cast<Ark_ColorFilter>(ColorFilter_serializer::read(valueDeserializer));
-        }
-        else if (colorFilter_buf__selector == 1) {
-            colorFilter_buf_.selector = 1;
-            colorFilter_buf_.value1 = static_cast<Ark_drawing_ColorFilter>(drawing_ColorFilter_serializer::read(valueDeserializer));
-        }
-        else {
-            INTEROP_FATAL("One of the branches for colorFilter_buf_ has to be chosen through deserialisation.");
-        }
-        colorFilter_buf.value = static_cast<Ark_ColorFilterType>(colorFilter_buf_);
+        paragraphSpacing_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.colorFilter = colorFilter_buf;
+    value.paragraphSpacing = paragraphSpacing_buf;
     return value;
 }
-inline void NativeEmbedDataInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedDataInfo value)
+inline void RichEditorParagraphStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphStyleOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_status = value.status;
-    Ark_Int32 value_status_type = INTEROP_RUNTIME_UNDEFINED;
-    value_status_type = runtimeType(value_status);
-    valueSerializer.writeInt8(value_status_type);
-    if ((value_status_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_status_value = value_status.value;
-        valueSerializer.writeInt32(static_cast<Ark_NativeEmbedStatus>(value_status_value));
-    }
-    const auto value_surfaceId = value.surfaceId;
-    Ark_Int32 value_surfaceId_type = INTEROP_RUNTIME_UNDEFINED;
-    value_surfaceId_type = runtimeType(value_surfaceId);
-    valueSerializer.writeInt8(value_surfaceId_type);
-    if ((value_surfaceId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_surfaceId_value = value_surfaceId.value;
-        valueSerializer.writeString(value_surfaceId_value);
-    }
-    const auto value_embedId = value.embedId;
-    Ark_Int32 value_embedId_type = INTEROP_RUNTIME_UNDEFINED;
-    value_embedId_type = runtimeType(value_embedId);
-    valueSerializer.writeInt8(value_embedId_type);
-    if ((value_embedId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_embedId_value = value_embedId.value;
-        valueSerializer.writeString(value_embedId_value);
+    const auto value_start = value.start;
+    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
+    value_start_type = runtimeType(value_start);
+    valueSerializer.writeInt8(value_start_type);
+    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_start_value = value_start.value;
+        valueSerializer.writeNumber(value_start_value);
     }
-    const auto value_info = value.info;
-    Ark_Int32 value_info_type = INTEROP_RUNTIME_UNDEFINED;
-    value_info_type = runtimeType(value_info);
-    valueSerializer.writeInt8(value_info_type);
-    if ((value_info_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_info_value = value_info.value;
-        NativeEmbedInfo_serializer::write(valueSerializer, value_info_value);
+    const auto value_end = value.end;
+    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
+    value_end_type = runtimeType(value_end);
+    valueSerializer.writeInt8(value_end_type);
+    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_end_value = value_end.value;
+        valueSerializer.writeNumber(value_end_value);
     }
+    const auto value_style = value.style;
+    RichEditorParagraphStyle_serializer::write(valueSerializer, value_style);
 }
-inline Ark_NativeEmbedDataInfo NativeEmbedDataInfo_serializer::read(DeserializerBase& buffer)
+inline Ark_RichEditorParagraphStyleOptions RichEditorParagraphStyleOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_NativeEmbedDataInfo value = {};
+    Ark_RichEditorParagraphStyleOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto status_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_NativeEmbedStatus status_buf = {};
-    status_buf.tag = status_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((status_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        status_buf.value = static_cast<Ark_NativeEmbedStatus>(valueDeserializer.readInt32());
-    }
-    value.status = status_buf;
-    const auto surfaceId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String surfaceId_buf = {};
-    surfaceId_buf.tag = surfaceId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((surfaceId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        surfaceId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
-    }
-    value.surfaceId = surfaceId_buf;
-    const auto embedId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String embedId_buf = {};
-    embedId_buf.tag = embedId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((embedId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        embedId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.embedId = embedId_buf;
-    const auto info_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_NativeEmbedInfo info_buf = {};
-    info_buf.tag = info_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((info_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.start = start_buf;
+    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number end_buf = {};
+    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        info_buf.value = NativeEmbedInfo_serializer::read(valueDeserializer);
+        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.info = info_buf;
+    value.end = end_buf;
+    value.style = RichEditorParagraphStyle_serializer::read(valueDeserializer);
     return value;
 }
-inline void NativeEmbedTouchInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedTouchInfo value)
+inline void RotationGestureEvent_serializer::write(SerializerBase& buffer, Ark_RotationGestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_embedId = value.embedId;
-    Ark_Int32 value_embedId_type = INTEROP_RUNTIME_UNDEFINED;
-    value_embedId_type = runtimeType(value_embedId);
-    valueSerializer.writeInt8(value_embedId_type);
-    if ((value_embedId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_embedId_value = value_embedId.value;
-        valueSerializer.writeString(value_embedId_value);
-    }
-    const auto value_touchEvent = value.touchEvent;
-    Ark_Int32 value_touchEvent_type = INTEROP_RUNTIME_UNDEFINED;
-    value_touchEvent_type = runtimeType(value_touchEvent);
-    valueSerializer.writeInt8(value_touchEvent_type);
-    if ((value_touchEvent_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_touchEvent_value = value_touchEvent.value;
-        TouchEvent_serializer::write(valueSerializer, value_touchEvent_value);
-    }
-    const auto value_result = value.result;
-    Ark_Int32 value_result_type = INTEROP_RUNTIME_UNDEFINED;
-    value_result_type = runtimeType(value_result);
-    valueSerializer.writeInt8(value_result_type);
-    if ((value_result_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_result_value = value_result.value;
-        EventResult_serializer::write(valueSerializer, value_result_value);
-    }
+    valueSerializer.writePointer(value);
 }
-inline Ark_NativeEmbedTouchInfo NativeEmbedTouchInfo_serializer::read(DeserializerBase& buffer)
+inline Ark_RotationGestureEvent RotationGestureEvent_serializer::read(DeserializerBase& buffer)
 {
-    Ark_NativeEmbedTouchInfo value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto embedId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String embedId_buf = {};
-    embedId_buf.tag = embedId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((embedId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        embedId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
-    }
-    value.embedId = embedId_buf;
-    const auto touchEvent_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TouchEvent touchEvent_buf = {};
-    touchEvent_buf.tag = touchEvent_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((touchEvent_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        touchEvent_buf.value = static_cast<Ark_TouchEvent>(TouchEvent_serializer::read(valueDeserializer));
-    }
-    value.touchEvent = touchEvent_buf;
-    const auto result_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_EventResult result_buf = {};
-    result_buf.tag = result_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((result_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        result_buf.value = static_cast<Ark_EventResult>(EventResult_serializer::read(valueDeserializer));
-    }
-    value.result = result_buf;
-    return value;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_RotationGestureEvent>(ptr);
 }
-inline void ResourceImageAttachmentOptions_serializer::write(SerializerBase& buffer, Ark_ResourceImageAttachmentOptions value)
+inline void SectionOptions_serializer::write(SerializerBase& buffer, Ark_SectionOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_resourceValue = value.resourceValue;
-    Ark_Int32 value_resourceValue_type = INTEROP_RUNTIME_UNDEFINED;
-    value_resourceValue_type = runtimeType(value_resourceValue);
-    valueSerializer.writeInt8(value_resourceValue_type);
-    if ((value_resourceValue_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_resourceValue_value = value_resourceValue.value;
-        Ark_Int32 value_resourceValue_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_resourceValue_value_type = value_resourceValue_value.selector;
-        if (value_resourceValue_value_type == 0) {
+    const auto value_itemsCount = value.itemsCount;
+    valueSerializer.writeNumber(value_itemsCount);
+    const auto value_crossCount = value.crossCount;
+    Ark_Int32 value_crossCount_type = INTEROP_RUNTIME_UNDEFINED;
+    value_crossCount_type = runtimeType(value_crossCount);
+    valueSerializer.writeInt8(value_crossCount_type);
+    if ((value_crossCount_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_crossCount_value = value_crossCount.value;
+        valueSerializer.writeNumber(value_crossCount_value);
+    }
+    const auto value_onGetItemMainSizeByIndex = value.onGetItemMainSizeByIndex;
+    Ark_Int32 value_onGetItemMainSizeByIndex_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onGetItemMainSizeByIndex_type = runtimeType(value_onGetItemMainSizeByIndex);
+    valueSerializer.writeInt8(value_onGetItemMainSizeByIndex_type);
+    if ((value_onGetItemMainSizeByIndex_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onGetItemMainSizeByIndex_value = value_onGetItemMainSizeByIndex.value;
+        valueSerializer.writeCallbackResource(value_onGetItemMainSizeByIndex_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onGetItemMainSizeByIndex_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onGetItemMainSizeByIndex_value.callSync));
+    }
+    const auto value_columnsGap = value.columnsGap;
+    Ark_Int32 value_columnsGap_type = INTEROP_RUNTIME_UNDEFINED;
+    value_columnsGap_type = runtimeType(value_columnsGap);
+    valueSerializer.writeInt8(value_columnsGap_type);
+    if ((value_columnsGap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_columnsGap_value = value_columnsGap.value;
+        Ark_Int32 value_columnsGap_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_columnsGap_value_type = value_columnsGap_value.selector;
+        if (value_columnsGap_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_resourceValue_value_0 = value_resourceValue_value.value0;
-            valueSerializer.writeString(value_resourceValue_value_0);
+            const auto value_columnsGap_value_0 = value_columnsGap_value.value0;
+            valueSerializer.writeString(value_columnsGap_value_0);
         }
-        else if (value_resourceValue_value_type == 1) {
+        else if (value_columnsGap_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_resourceValue_value_1 = value_resourceValue_value.value1;
-            Resource_serializer::write(valueSerializer, value_resourceValue_value_1);
+            const auto value_columnsGap_value_1 = value_columnsGap_value.value1;
+            valueSerializer.writeNumber(value_columnsGap_value_1);
+        }
+        else if (value_columnsGap_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_columnsGap_value_2 = value_columnsGap_value.value2;
+            Resource_serializer::write(valueSerializer, value_columnsGap_value_2);
         }
     }
-    const auto value_size = value.size;
-    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
-    value_size_type = runtimeType(value_size);
-    valueSerializer.writeInt8(value_size_type);
-    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_size_value = value_size.value;
-        SizeOptions_serializer::write(valueSerializer, value_size_value);
-    }
-    const auto value_verticalAlign = value.verticalAlign;
-    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value_verticalAlign_type = runtimeType(value_verticalAlign);
-    valueSerializer.writeInt8(value_verticalAlign_type);
-    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_verticalAlign_value = value_verticalAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
-    }
-    const auto value_objectFit = value.objectFit;
-    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
-    value_objectFit_type = runtimeType(value_objectFit);
-    valueSerializer.writeInt8(value_objectFit_type);
-    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_objectFit_value = value_objectFit.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
-    }
-    const auto value_layoutStyle = value.layoutStyle;
-    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutStyle_type = runtimeType(value_layoutStyle);
-    valueSerializer.writeInt8(value_layoutStyle_type);
-    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutStyle_value = value_layoutStyle.value;
-        ImageAttachmentLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
-    }
-    const auto value_colorFilter = value.colorFilter;
-    Ark_Int32 value_colorFilter_type = INTEROP_RUNTIME_UNDEFINED;
-    value_colorFilter_type = runtimeType(value_colorFilter);
-    valueSerializer.writeInt8(value_colorFilter_type);
-    if ((value_colorFilter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_colorFilter_value = value_colorFilter.value;
-        Ark_Int32 value_colorFilter_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_colorFilter_value_type = value_colorFilter_value.selector;
-        if (value_colorFilter_value_type == 0) {
+    const auto value_rowsGap = value.rowsGap;
+    Ark_Int32 value_rowsGap_type = INTEROP_RUNTIME_UNDEFINED;
+    value_rowsGap_type = runtimeType(value_rowsGap);
+    valueSerializer.writeInt8(value_rowsGap_type);
+    if ((value_rowsGap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_rowsGap_value = value_rowsGap.value;
+        Ark_Int32 value_rowsGap_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_rowsGap_value_type = value_rowsGap_value.selector;
+        if (value_rowsGap_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_colorFilter_value_0 = value_colorFilter_value.value0;
-            ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_0);
+            const auto value_rowsGap_value_0 = value_rowsGap_value.value0;
+            valueSerializer.writeString(value_rowsGap_value_0);
         }
-        else if (value_colorFilter_value_type == 1) {
+        else if (value_rowsGap_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_colorFilter_value_1 = value_colorFilter_value.value1;
-            drawing_ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_1);
+            const auto value_rowsGap_value_1 = value_rowsGap_value.value1;
+            valueSerializer.writeNumber(value_rowsGap_value_1);
+        }
+        else if (value_rowsGap_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_rowsGap_value_2 = value_rowsGap_value.value2;
+            Resource_serializer::write(valueSerializer, value_rowsGap_value_2);
         }
     }
-    const auto value_syncLoad = value.syncLoad;
-    Ark_Int32 value_syncLoad_type = INTEROP_RUNTIME_UNDEFINED;
-    value_syncLoad_type = runtimeType(value_syncLoad);
-    valueSerializer.writeInt8(value_syncLoad_type);
-    if ((value_syncLoad_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_syncLoad_value = value_syncLoad.value;
-        valueSerializer.writeBoolean(value_syncLoad_value);
+    const auto value_margin = value.margin;
+    Ark_Int32 value_margin_type = INTEROP_RUNTIME_UNDEFINED;
+    value_margin_type = runtimeType(value_margin);
+    valueSerializer.writeInt8(value_margin_type);
+    if ((value_margin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_margin_value = value_margin.value;
+        Ark_Int32 value_margin_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_margin_value_type = value_margin_value.selector;
+        if (value_margin_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_margin_value_0 = value_margin_value.value0;
+            Padding_serializer::write(valueSerializer, value_margin_value_0);
+        }
+        else if ((value_margin_value_type == 1) || (value_margin_value_type == 1) || (value_margin_value_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value_margin_value_1 = value_margin_value.value1;
+            Ark_Int32 value_margin_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_margin_value_1_type = value_margin_value_1.selector;
+            if (value_margin_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_margin_value_1_0 = value_margin_value_1.value0;
+                valueSerializer.writeString(value_margin_value_1_0);
+            }
+            else if (value_margin_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_margin_value_1_1 = value_margin_value_1.value1;
+                valueSerializer.writeNumber(value_margin_value_1_1);
+            }
+            else if (value_margin_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_margin_value_1_2 = value_margin_value_1.value2;
+                Resource_serializer::write(valueSerializer, value_margin_value_1_2);
+            }
+        }
     }
 }
-inline Ark_ResourceImageAttachmentOptions ResourceImageAttachmentOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_SectionOptions SectionOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_ResourceImageAttachmentOptions value = {};
+    Ark_SectionOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto resourceValue_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceStr resourceValue_buf = {};
-    resourceValue_buf.tag = resourceValue_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((resourceValue_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 resourceValue_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceStr resourceValue_buf_ = {};
-        resourceValue_buf_.selector = resourceValue_buf__selector;
-        if (resourceValue_buf__selector == 0) {
-            resourceValue_buf_.selector = 0;
-            resourceValue_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (resourceValue_buf__selector == 1) {
-            resourceValue_buf_.selector = 1;
-            resourceValue_buf_.value1 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for resourceValue_buf_ has to be chosen through deserialisation.");
-        }
-        resourceValue_buf.value = static_cast<Ark_ResourceStr>(resourceValue_buf_);
-    }
-    value.resourceValue = resourceValue_buf;
-    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SizeOptions size_buf = {};
-    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        size_buf.value = SizeOptions_serializer::read(valueDeserializer);
-    }
-    value.size = size_buf;
-    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageSpanAlignment verticalAlign_buf = {};
-    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.itemsCount = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto crossCount_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number crossCount_buf = {};
+    crossCount_buf.tag = crossCount_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((crossCount_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
+        crossCount_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.verticalAlign = verticalAlign_buf;
-    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageFit objectFit_buf = {};
-    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.crossCount = crossCount_buf;
+    const auto onGetItemMainSizeByIndex_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_GetItemMainSizeByIndex onGetItemMainSizeByIndex_buf = {};
+    onGetItemMainSizeByIndex_buf.tag = onGetItemMainSizeByIndex_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onGetItemMainSizeByIndex_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
+        onGetItemMainSizeByIndex_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number index, const Callback_Number_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_GetItemMainSizeByIndex)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number index, const Callback_Number_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_GetItemMainSizeByIndex))))};
     }
-    value.objectFit = objectFit_buf;
-    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageAttachmentLayoutStyle layoutStyle_buf = {};
-    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onGetItemMainSizeByIndex = onGetItemMainSizeByIndex_buf;
+    const auto columnsGap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension columnsGap_buf = {};
+    columnsGap_buf.tag = columnsGap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((columnsGap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        layoutStyle_buf.value = ImageAttachmentLayoutStyle_serializer::read(valueDeserializer);
+        const Ark_Int8 columnsGap_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension columnsGap_buf_ = {};
+        columnsGap_buf_.selector = columnsGap_buf__selector;
+        if (columnsGap_buf__selector == 0) {
+            columnsGap_buf_.selector = 0;
+            columnsGap_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (columnsGap_buf__selector == 1) {
+            columnsGap_buf_.selector = 1;
+            columnsGap_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (columnsGap_buf__selector == 2) {
+            columnsGap_buf_.selector = 2;
+            columnsGap_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for columnsGap_buf_ has to be chosen through deserialisation.");
+        }
+        columnsGap_buf.value = static_cast<Ark_Dimension>(columnsGap_buf_);
     }
-    value.layoutStyle = layoutStyle_buf;
-    const auto colorFilter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ColorFilterType colorFilter_buf = {};
-    colorFilter_buf.tag = colorFilter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((colorFilter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.columnsGap = columnsGap_buf;
+    const auto rowsGap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension rowsGap_buf = {};
+    rowsGap_buf.tag = rowsGap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((rowsGap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 colorFilter_buf__selector = valueDeserializer.readInt8();
-        Ark_ColorFilterType colorFilter_buf_ = {};
-        colorFilter_buf_.selector = colorFilter_buf__selector;
-        if (colorFilter_buf__selector == 0) {
-            colorFilter_buf_.selector = 0;
-            colorFilter_buf_.value0 = static_cast<Ark_ColorFilter>(ColorFilter_serializer::read(valueDeserializer));
+        const Ark_Int8 rowsGap_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension rowsGap_buf_ = {};
+        rowsGap_buf_.selector = rowsGap_buf__selector;
+        if (rowsGap_buf__selector == 0) {
+            rowsGap_buf_.selector = 0;
+            rowsGap_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (colorFilter_buf__selector == 1) {
-            colorFilter_buf_.selector = 1;
-            colorFilter_buf_.value1 = static_cast<Ark_drawing_ColorFilter>(drawing_ColorFilter_serializer::read(valueDeserializer));
+        else if (rowsGap_buf__selector == 1) {
+            rowsGap_buf_.selector = 1;
+            rowsGap_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (rowsGap_buf__selector == 2) {
+            rowsGap_buf_.selector = 2;
+            rowsGap_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for colorFilter_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for rowsGap_buf_ has to be chosen through deserialisation.");
         }
-        colorFilter_buf.value = static_cast<Ark_ColorFilterType>(colorFilter_buf_);
+        rowsGap_buf.value = static_cast<Ark_Dimension>(rowsGap_buf_);
     }
-    value.colorFilter = colorFilter_buf;
-    const auto syncLoad_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean syncLoad_buf = {};
-    syncLoad_buf.tag = syncLoad_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((syncLoad_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.rowsGap = rowsGap_buf;
+    const auto margin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Margin_Dimension margin_buf = {};
+    margin_buf.tag = margin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((margin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        syncLoad_buf.value = valueDeserializer.readBoolean();
+        const Ark_Int8 margin_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Margin_Dimension margin_buf_ = {};
+        margin_buf_.selector = margin_buf__selector;
+        if (margin_buf__selector == 0) {
+            margin_buf_.selector = 0;
+            margin_buf_.value0 = Padding_serializer::read(valueDeserializer);
+        }
+        else if (margin_buf__selector == 1) {
+            margin_buf_.selector = 1;
+            const Ark_Int8 margin_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension margin_buf__u = {};
+            margin_buf__u.selector = margin_buf__u_selector;
+            if (margin_buf__u_selector == 0) {
+                margin_buf__u.selector = 0;
+                margin_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (margin_buf__u_selector == 1) {
+                margin_buf__u.selector = 1;
+                margin_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (margin_buf__u_selector == 2) {
+                margin_buf__u.selector = 2;
+                margin_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for margin_buf__u has to be chosen through deserialisation.");
+            }
+            margin_buf_.value1 = static_cast<Ark_Dimension>(margin_buf__u);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for margin_buf_ has to be chosen through deserialisation.");
+        }
+        margin_buf.value = static_cast<Ark_Union_Margin_Dimension>(margin_buf_);
     }
-    value.syncLoad = syncLoad_buf;
+    value.margin = margin_buf;
     return value;
 }
-inline void RichEditorImageSpanStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanStyle value)
+inline void SheetOptions_serializer::write(SerializerBase& buffer, Ark_SheetOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_size = value.size;
-    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
-    value_size_type = runtimeType(value_size);
-    valueSerializer.writeInt8(value_size_type);
-    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_size_value = value_size.value;
-        const auto value_size_value_0 = value_size_value.value0;
-        Ark_Int32 value_size_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-        value_size_value_0_type = value_size_value_0.selector;
-        if (value_size_value_0_type == 0) {
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_size_value_0_0 = value_size_value_0.value0;
-            valueSerializer.writeString(value_size_value_0_0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_size_value_0_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_size_value_0_1 = value_size_value_0.value1;
-            valueSerializer.writeNumber(value_size_value_0_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-        else if (value_size_value_0_type == 2) {
+        else if (value_backgroundColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_size_value_0_2 = value_size_value_0.value2;
-            Resource_serializer::write(valueSerializer, value_size_value_0_2);
-        }
-        const auto value_size_value_1 = value_size_value.value1;
-        Ark_Int32 value_size_value_1_type = INTEROP_RUNTIME_UNDEFINED;
-        value_size_value_1_type = value_size_value_1.selector;
-        if (value_size_value_1_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_size_value_1_0 = value_size_value_1.value0;
-            valueSerializer.writeString(value_size_value_1_0);
-        }
-        else if (value_size_value_1_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_size_value_1_1 = value_size_value_1.value1;
-            valueSerializer.writeNumber(value_size_value_1_1);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
         }
-        else if (value_size_value_1_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_size_value_1_2 = value_size_value_1.value2;
-            Resource_serializer::write(valueSerializer, value_size_value_1_2);
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
-    const auto value_verticalAlign = value.verticalAlign;
-    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
-    value_verticalAlign_type = runtimeType(value_verticalAlign);
-    valueSerializer.writeInt8(value_verticalAlign_type);
-    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_verticalAlign_value = value_verticalAlign.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
+    const auto value_onAppear = value.onAppear;
+    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onAppear_type = runtimeType(value_onAppear);
+    valueSerializer.writeInt8(value_onAppear_type);
+    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onAppear_value = value_onAppear.value;
+        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
     }
-    const auto value_objectFit = value.objectFit;
-    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
-    value_objectFit_type = runtimeType(value_objectFit);
-    valueSerializer.writeInt8(value_objectFit_type);
-    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_objectFit_value = value_objectFit.value;
-        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
+    const auto value_onDisappear = value.onDisappear;
+    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDisappear_type = runtimeType(value_onDisappear);
+    valueSerializer.writeInt8(value_onDisappear_type);
+    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDisappear_value = value_onDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
     }
-    const auto value_layoutStyle = value.layoutStyle;
-    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutStyle_type = runtimeType(value_layoutStyle);
-    valueSerializer.writeInt8(value_layoutStyle_type);
-    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutStyle_value = value_layoutStyle.value;
-        RichEditorLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
+    const auto value_onWillAppear = value.onWillAppear;
+    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillAppear_type = runtimeType(value_onWillAppear);
+    valueSerializer.writeInt8(value_onWillAppear_type);
+    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillAppear_value = value_onWillAppear.value;
+        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
     }
-}
-inline Ark_RichEditorImageSpanStyle RichEditorImageSpanStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorImageSpanStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Tuple_Dimension_Dimension size_buf = {};
-    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        Ark_Tuple_Dimension_Dimension size_buf_ = {};
-        const Ark_Int8 size_buf__value0_buf_selector = valueDeserializer.readInt8();
-        Ark_Dimension size_buf__value0_buf = {};
-        size_buf__value0_buf.selector = size_buf__value0_buf_selector;
-        if (size_buf__value0_buf_selector == 0) {
-            size_buf__value0_buf.selector = 0;
-            size_buf__value0_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (size_buf__value0_buf_selector == 1) {
-            size_buf__value0_buf.selector = 1;
-            size_buf__value0_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (size_buf__value0_buf_selector == 2) {
-            size_buf__value0_buf.selector = 2;
-            size_buf__value0_buf.value2 = Resource_serializer::read(valueDeserializer);
+    const auto value_onWillDisappear = value.onWillDisappear;
+    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
+    valueSerializer.writeInt8(value_onWillDisappear_type);
+    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDisappear_value = value_onWillDisappear.value;
+        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    }
+    const auto value_height = value.height;
+    Ark_Int32 value_height_type = INTEROP_RUNTIME_UNDEFINED;
+    value_height_type = runtimeType(value_height);
+    valueSerializer.writeInt8(value_height_type);
+    if ((value_height_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_height_value = value_height.value;
+        Ark_Int32 value_height_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_height_value_type = value_height_value.selector;
+        if (value_height_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_height_value_0 = value_height_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_height_value_0));
         }
-        else {
-            INTEROP_FATAL("One of the branches for size_buf__value0_buf has to be chosen through deserialisation.");
+        else if ((value_height_value_type == 1) || (value_height_value_type == 1) || (value_height_value_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value_height_value_1 = value_height_value.value1;
+            Ark_Int32 value_height_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_height_value_1_type = value_height_value_1.selector;
+            if (value_height_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_height_value_1_0 = value_height_value_1.value0;
+                valueSerializer.writeString(value_height_value_1_0);
+            }
+            else if (value_height_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_height_value_1_1 = value_height_value_1.value1;
+                valueSerializer.writeNumber(value_height_value_1_1);
+            }
+            else if (value_height_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_height_value_1_2 = value_height_value_1.value2;
+                Resource_serializer::write(valueSerializer, value_height_value_1_2);
+            }
         }
-        size_buf_.value0 = static_cast<Ark_Dimension>(size_buf__value0_buf);
-        const Ark_Int8 size_buf__value1_buf_selector = valueDeserializer.readInt8();
-        Ark_Dimension size_buf__value1_buf = {};
-        size_buf__value1_buf.selector = size_buf__value1_buf_selector;
-        if (size_buf__value1_buf_selector == 0) {
-            size_buf__value1_buf.selector = 0;
-            size_buf__value1_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    const auto value_dragBar = value.dragBar;
+    Ark_Int32 value_dragBar_type = INTEROP_RUNTIME_UNDEFINED;
+    value_dragBar_type = runtimeType(value_dragBar);
+    valueSerializer.writeInt8(value_dragBar_type);
+    if ((value_dragBar_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_dragBar_value = value_dragBar.value;
+        valueSerializer.writeBoolean(value_dragBar_value);
+    }
+    const auto value_maskColor = value.maskColor;
+    Ark_Int32 value_maskColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maskColor_type = runtimeType(value_maskColor);
+    valueSerializer.writeInt8(value_maskColor_type);
+    if ((value_maskColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maskColor_value = value_maskColor.value;
+        Ark_Int32 value_maskColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_maskColor_value_type = value_maskColor_value.selector;
+        if (value_maskColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_maskColor_value_0 = value_maskColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_maskColor_value_0));
         }
-        else if (size_buf__value1_buf_selector == 1) {
-            size_buf__value1_buf.selector = 1;
-            size_buf__value1_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (value_maskColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_maskColor_value_1 = value_maskColor_value.value1;
+            valueSerializer.writeNumber(value_maskColor_value_1);
         }
-        else if (size_buf__value1_buf_selector == 2) {
-            size_buf__value1_buf.selector = 2;
-            size_buf__value1_buf.value2 = Resource_serializer::read(valueDeserializer);
+        else if (value_maskColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_maskColor_value_2 = value_maskColor_value.value2;
+            valueSerializer.writeString(value_maskColor_value_2);
         }
-        else {
-            INTEROP_FATAL("One of the branches for size_buf__value1_buf has to be chosen through deserialisation.");
+        else if (value_maskColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_maskColor_value_3 = value_maskColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_maskColor_value_3);
         }
-        size_buf_.value1 = static_cast<Ark_Dimension>(size_buf__value1_buf);
-        size_buf.value = size_buf_;
-    }
-    value.size = size_buf;
-    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageSpanAlignment verticalAlign_buf = {};
-    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
     }
-    value.verticalAlign = verticalAlign_buf;
-    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ImageFit objectFit_buf = {};
-    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
-    }
-    value.objectFit = objectFit_buf;
-    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorLayoutStyle layoutStyle_buf = {};
-    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        layoutStyle_buf.value = RichEditorLayoutStyle_serializer::read(valueDeserializer);
-    }
-    value.layoutStyle = layoutStyle_buf;
-    return value;
-}
-inline void RichEditorImageSpanStyleResult_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanStyleResult value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_size = value.size;
-    const auto value_size_0 = value_size.value0;
-    valueSerializer.writeNumber(value_size_0);
-    const auto value_size_1 = value_size.value1;
-    valueSerializer.writeNumber(value_size_1);
-    const auto value_verticalAlign = value.verticalAlign;
-    valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign));
-    const auto value_objectFit = value.objectFit;
-    valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit));
-    const auto value_layoutStyle = value.layoutStyle;
-    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutStyle_type = runtimeType(value_layoutStyle);
-    valueSerializer.writeInt8(value_layoutStyle_type);
-    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutStyle_value = value_layoutStyle.value;
-        RichEditorLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
+    const auto value_detents = value.detents;
+    Ark_Int32 value_detents_type = INTEROP_RUNTIME_UNDEFINED;
+    value_detents_type = runtimeType(value_detents);
+    valueSerializer.writeInt8(value_detents_type);
+    if ((value_detents_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_detents_value = value_detents.value;
+        const auto value_detents_value_0 = value_detents_value.value0;
+        Ark_Int32 value_detents_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+        value_detents_value_0_type = value_detents_value_0.selector;
+        if (value_detents_value_0_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_detents_value_0_0 = value_detents_value_0.value0;
+            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_0_0));
+        }
+        else if ((value_detents_value_0_type == 1) || (value_detents_value_0_type == 1) || (value_detents_value_0_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value_detents_value_0_1 = value_detents_value_0.value1;
+            Ark_Int32 value_detents_value_0_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_detents_value_0_1_type = value_detents_value_0_1.selector;
+            if (value_detents_value_0_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_detents_value_0_1_0 = value_detents_value_0_1.value0;
+                valueSerializer.writeString(value_detents_value_0_1_0);
+            }
+            else if (value_detents_value_0_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_detents_value_0_1_1 = value_detents_value_0_1.value1;
+                valueSerializer.writeNumber(value_detents_value_0_1_1);
+            }
+            else if (value_detents_value_0_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_detents_value_0_1_2 = value_detents_value_0_1.value2;
+                Resource_serializer::write(valueSerializer, value_detents_value_0_1_2);
+            }
+        }
+        const auto value_detents_value_1 = value_detents_value.value1;
+        Ark_Int32 value_detents_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+        value_detents_value_1_type = runtimeType(value_detents_value_1);
+        valueSerializer.writeInt8(value_detents_value_1_type);
+        if ((value_detents_value_1_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+            const auto value_detents_value_1_value = value_detents_value_1.value;
+            Ark_Int32 value_detents_value_1_value_type = INTEROP_RUNTIME_UNDEFINED;
+            value_detents_value_1_value_type = value_detents_value_1_value.selector;
+            if (value_detents_value_1_value_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_detents_value_1_value_0 = value_detents_value_1_value.value0;
+                valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_1_value_0));
+            }
+            else if ((value_detents_value_1_value_type == 1) || (value_detents_value_1_value_type == 1) || (value_detents_value_1_value_type == 1)) {
+                valueSerializer.writeInt8(1);
+                const auto value_detents_value_1_value_1 = value_detents_value_1_value.value1;
+                Ark_Int32 value_detents_value_1_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+                value_detents_value_1_value_1_type = value_detents_value_1_value_1.selector;
+                if (value_detents_value_1_value_1_type == 0) {
+                    valueSerializer.writeInt8(0);
+                    const auto value_detents_value_1_value_1_0 = value_detents_value_1_value_1.value0;
+                    valueSerializer.writeString(value_detents_value_1_value_1_0);
+                }
+                else if (value_detents_value_1_value_1_type == 1) {
+                    valueSerializer.writeInt8(1);
+                    const auto value_detents_value_1_value_1_1 = value_detents_value_1_value_1.value1;
+                    valueSerializer.writeNumber(value_detents_value_1_value_1_1);
+                }
+                else if (value_detents_value_1_value_1_type == 2) {
+                    valueSerializer.writeInt8(2);
+                    const auto value_detents_value_1_value_1_2 = value_detents_value_1_value_1.value2;
+                    Resource_serializer::write(valueSerializer, value_detents_value_1_value_1_2);
+                }
+            }
+        }
+        const auto value_detents_value_2 = value_detents_value.value2;
+        Ark_Int32 value_detents_value_2_type = INTEROP_RUNTIME_UNDEFINED;
+        value_detents_value_2_type = runtimeType(value_detents_value_2);
+        valueSerializer.writeInt8(value_detents_value_2_type);
+        if ((value_detents_value_2_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+            const auto value_detents_value_2_value = value_detents_value_2.value;
+            Ark_Int32 value_detents_value_2_value_type = INTEROP_RUNTIME_UNDEFINED;
+            value_detents_value_2_value_type = value_detents_value_2_value.selector;
+            if (value_detents_value_2_value_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_detents_value_2_value_0 = value_detents_value_2_value.value0;
+                valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detents_value_2_value_0));
+            }
+            else if ((value_detents_value_2_value_type == 1) || (value_detents_value_2_value_type == 1) || (value_detents_value_2_value_type == 1)) {
+                valueSerializer.writeInt8(1);
+                const auto value_detents_value_2_value_1 = value_detents_value_2_value.value1;
+                Ark_Int32 value_detents_value_2_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+                value_detents_value_2_value_1_type = value_detents_value_2_value_1.selector;
+                if (value_detents_value_2_value_1_type == 0) {
+                    valueSerializer.writeInt8(0);
+                    const auto value_detents_value_2_value_1_0 = value_detents_value_2_value_1.value0;
+                    valueSerializer.writeString(value_detents_value_2_value_1_0);
+                }
+                else if (value_detents_value_2_value_1_type == 1) {
+                    valueSerializer.writeInt8(1);
+                    const auto value_detents_value_2_value_1_1 = value_detents_value_2_value_1.value1;
+                    valueSerializer.writeNumber(value_detents_value_2_value_1_1);
+                }
+                else if (value_detents_value_2_value_1_type == 2) {
+                    valueSerializer.writeInt8(2);
+                    const auto value_detents_value_2_value_1_2 = value_detents_value_2_value_1.value2;
+                    Resource_serializer::write(valueSerializer, value_detents_value_2_value_1_2);
+                }
+            }
+        }
     }
-}
-inline Ark_RichEditorImageSpanStyleResult RichEditorImageSpanStyleResult_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorImageSpanStyleResult value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    Ark_Tuple_Number_Number size_buf = {};
-    size_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    size_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.size = size_buf;
-    value.verticalAlign = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
-    value.objectFit = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
-    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorLayoutStyle layoutStyle_buf = {};
-    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        layoutStyle_buf.value = RichEditorLayoutStyle_serializer::read(valueDeserializer);
+    const auto value_blurStyle = value.blurStyle;
+    Ark_Int32 value_blurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_blurStyle_type = runtimeType(value_blurStyle);
+    valueSerializer.writeInt8(value_blurStyle_type);
+    if ((value_blurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_blurStyle_value = value_blurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_blurStyle_value));
     }
-    value.layoutStyle = layoutStyle_buf;
-    return value;
-}
-inline void RichEditorParagraphResult_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphResult value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_style = value.style;
-    RichEditorParagraphStyle_serializer::write(valueSerializer, value_style);
-    const auto value_range = value.range;
-    const auto value_range_0 = value_range.value0;
-    valueSerializer.writeNumber(value_range_0);
-    const auto value_range_1 = value_range.value1;
-    valueSerializer.writeNumber(value_range_1);
-}
-inline Ark_RichEditorParagraphResult RichEditorParagraphResult_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorParagraphResult value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.style = RichEditorParagraphStyle_serializer::read(valueDeserializer);
-    Ark_Tuple_Number_Number range_buf = {};
-    range_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    range_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.range = range_buf;
-    return value;
-}
-inline void RichEditorTextStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorTextStyle value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_fontColor = value.fontColor;
-    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontColor_type = runtimeType(value_fontColor);
-    valueSerializer.writeInt8(value_fontColor_type);
-    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontColor_value = value_fontColor.value;
-        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontColor_value_type = value_fontColor_value.selector;
-        if (value_fontColor_value_type == 0) {
+    const auto value_showClose = value.showClose;
+    Ark_Int32 value_showClose_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showClose_type = runtimeType(value_showClose);
+    valueSerializer.writeInt8(value_showClose_type);
+    if ((value_showClose_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showClose_value = value_showClose.value;
+        Ark_Int32 value_showClose_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_showClose_value_type = value_showClose_value.selector;
+        if (value_showClose_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontColor_value_0 = value_fontColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
+            const auto value_showClose_value_0 = value_showClose_value.value0;
+            valueSerializer.writeBoolean(value_showClose_value_0);
         }
-        else if (value_fontColor_value_type == 1) {
+        else if (value_showClose_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontColor_value_1 = value_fontColor_value.value1;
-            valueSerializer.writeNumber(value_fontColor_value_1);
+            const auto value_showClose_value_1 = value_showClose_value.value1;
+            Resource_serializer::write(valueSerializer, value_showClose_value_1);
         }
-        else if (value_fontColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_fontColor_value_2 = value_fontColor_value.value2;
-            valueSerializer.writeString(value_fontColor_value_2);
+    }
+    const auto value_preferType = value.preferType;
+    Ark_Int32 value_preferType_type = INTEROP_RUNTIME_UNDEFINED;
+    value_preferType_type = runtimeType(value_preferType);
+    valueSerializer.writeInt8(value_preferType_type);
+    if ((value_preferType_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_preferType_value = value_preferType.value;
+        valueSerializer.writeInt32(static_cast<Ark_SheetType>(value_preferType_value));
+    }
+    const auto value_title = value.title;
+    Ark_Int32 value_title_type = INTEROP_RUNTIME_UNDEFINED;
+    value_title_type = runtimeType(value_title);
+    valueSerializer.writeInt8(value_title_type);
+    if ((value_title_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_title_value = value_title.value;
+        Ark_Int32 value_title_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_title_value_type = value_title_value.selector;
+        if (value_title_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_title_value_0 = value_title_value.value0;
+            SheetTitleOptions_serializer::write(valueSerializer, value_title_value_0);
         }
-        else if (value_fontColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_fontColor_value_3 = value_fontColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
+        else if (value_title_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_title_value_1 = value_title_value.value1;
+            valueSerializer.writeCallbackResource(value_title_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_title_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_title_value_1.callSync));
         }
     }
-    const auto value_fontSize = value.fontSize;
-    Ark_Int32 value_fontSize_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontSize_type = runtimeType(value_fontSize);
-    valueSerializer.writeInt8(value_fontSize_type);
-    if ((value_fontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontSize_value = value_fontSize.value;
-        Ark_Int32 value_fontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontSize_value_type = value_fontSize_value.selector;
-        if (value_fontSize_value_type == 0) {
+    const auto value_shouldDismiss = value.shouldDismiss;
+    Ark_Int32 value_shouldDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shouldDismiss_type = runtimeType(value_shouldDismiss);
+    valueSerializer.writeInt8(value_shouldDismiss_type);
+    if ((value_shouldDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shouldDismiss_value = value_shouldDismiss.value;
+        valueSerializer.writeCallbackResource(value_shouldDismiss_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_shouldDismiss_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_shouldDismiss_value.callSync));
+    }
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
+    }
+    const auto value_onWillSpringBackWhenDismiss = value.onWillSpringBackWhenDismiss;
+    Ark_Int32 value_onWillSpringBackWhenDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillSpringBackWhenDismiss_type = runtimeType(value_onWillSpringBackWhenDismiss);
+    valueSerializer.writeInt8(value_onWillSpringBackWhenDismiss_type);
+    if ((value_onWillSpringBackWhenDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillSpringBackWhenDismiss_value = value_onWillSpringBackWhenDismiss.value;
+        valueSerializer.writeCallbackResource(value_onWillSpringBackWhenDismiss_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillSpringBackWhenDismiss_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillSpringBackWhenDismiss_value.callSync));
+    }
+    const auto value_enableOutsideInteractive = value.enableOutsideInteractive;
+    Ark_Int32 value_enableOutsideInteractive_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableOutsideInteractive_type = runtimeType(value_enableOutsideInteractive);
+    valueSerializer.writeInt8(value_enableOutsideInteractive_type);
+    if ((value_enableOutsideInteractive_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableOutsideInteractive_value = value_enableOutsideInteractive.value;
+        valueSerializer.writeBoolean(value_enableOutsideInteractive_value);
+    }
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if (value_width_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_fontSize_value_0 = value_fontSize_value.value0;
-            valueSerializer.writeString(value_fontSize_value_0);
+            const auto value_width_value_0 = value_width_value.value0;
+            valueSerializer.writeString(value_width_value_0);
         }
-        else if (value_fontSize_value_type == 1) {
+        else if (value_width_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontSize_value_1 = value_fontSize_value.value1;
-            valueSerializer.writeNumber(value_fontSize_value_1);
+            const auto value_width_value_1 = value_width_value.value1;
+            valueSerializer.writeNumber(value_width_value_1);
         }
-        else if (value_fontSize_value_type == 2) {
+        else if (value_width_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_fontSize_value_2 = value_fontSize_value.value2;
-            Resource_serializer::write(valueSerializer, value_fontSize_value_2);
+            const auto value_width_value_2 = value_width_value.value2;
+            Resource_serializer::write(valueSerializer, value_width_value_2);
         }
     }
-    const auto value_fontStyle = value.fontStyle;
-    Ark_Int32 value_fontStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontStyle_type = runtimeType(value_fontStyle);
-    valueSerializer.writeInt8(value_fontStyle_type);
-    if ((value_fontStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontStyle_value = value_fontStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle_value));
-    }
-    const auto value_fontWeight = value.fontWeight;
-    Ark_Int32 value_fontWeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontWeight_type = runtimeType(value_fontWeight);
-    valueSerializer.writeInt8(value_fontWeight_type);
-    if ((value_fontWeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontWeight_value = value_fontWeight.value;
-        Ark_Int32 value_fontWeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontWeight_value_type = value_fontWeight_value.selector;
-        if (value_fontWeight_value_type == 0) {
+    const auto value_borderWidth = value.borderWidth;
+    Ark_Int32 value_borderWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderWidth_type = runtimeType(value_borderWidth);
+    valueSerializer.writeInt8(value_borderWidth_type);
+    if ((value_borderWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderWidth_value = value_borderWidth.value;
+        Ark_Int32 value_borderWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderWidth_value_type = value_borderWidth_value.selector;
+        if ((value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0) || (value_borderWidth_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_fontWeight_value_0 = value_fontWeight_value.value0;
-            valueSerializer.writeNumber(value_fontWeight_value_0);
+            const auto value_borderWidth_value_0 = value_borderWidth_value.value0;
+            Ark_Int32 value_borderWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderWidth_value_0_type = value_borderWidth_value_0.selector;
+            if (value_borderWidth_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderWidth_value_0_0 = value_borderWidth_value_0.value0;
+                valueSerializer.writeString(value_borderWidth_value_0_0);
+            }
+            else if (value_borderWidth_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderWidth_value_0_1 = value_borderWidth_value_0.value1;
+                valueSerializer.writeNumber(value_borderWidth_value_0_1);
+            }
+            else if (value_borderWidth_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderWidth_value_0_2 = value_borderWidth_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_borderWidth_value_0_2);
+            }
         }
-        else if (value_fontWeight_value_type == 1) {
+        else if (value_borderWidth_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontWeight_value_1 = value_fontWeight_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_FontWeight>(value_fontWeight_value_1));
+            const auto value_borderWidth_value_1 = value_borderWidth_value.value1;
+            EdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_1);
         }
-        else if (value_fontWeight_value_type == 2) {
+        else if (value_borderWidth_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_fontWeight_value_2 = value_fontWeight_value.value2;
-            valueSerializer.writeString(value_fontWeight_value_2);
+            const auto value_borderWidth_value_2 = value_borderWidth_value.value2;
+            LocalizedEdgeWidths_serializer::write(valueSerializer, value_borderWidth_value_2);
         }
     }
-    const auto value_fontFamily = value.fontFamily;
-    Ark_Int32 value_fontFamily_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontFamily_type = runtimeType(value_fontFamily);
-    valueSerializer.writeInt8(value_fontFamily_type);
-    if ((value_fontFamily_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontFamily_value = value_fontFamily.value;
-        Ark_Int32 value_fontFamily_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_fontFamily_value_type = value_fontFamily_value.selector;
-        if (value_fontFamily_value_type == 0) {
+    const auto value_borderColor = value.borderColor;
+    Ark_Int32 value_borderColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderColor_type = runtimeType(value_borderColor);
+    valueSerializer.writeInt8(value_borderColor_type);
+    if ((value_borderColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderColor_value = value_borderColor.value;
+        Ark_Int32 value_borderColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderColor_value_type = value_borderColor_value.selector;
+        if ((value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0) || (value_borderColor_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_fontFamily_value_0 = value_fontFamily_value.value0;
-            valueSerializer.writeString(value_fontFamily_value_0);
+            const auto value_borderColor_value_0 = value_borderColor_value.value0;
+            Ark_Int32 value_borderColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_borderColor_value_0_type = value_borderColor_value_0.selector;
+            if (value_borderColor_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_borderColor_value_0_0 = value_borderColor_value_0.value0;
+                valueSerializer.writeInt32(static_cast<Ark_Color>(value_borderColor_value_0_0));
+            }
+            else if (value_borderColor_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_borderColor_value_0_1 = value_borderColor_value_0.value1;
+                valueSerializer.writeNumber(value_borderColor_value_0_1);
+            }
+            else if (value_borderColor_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_borderColor_value_0_2 = value_borderColor_value_0.value2;
+                valueSerializer.writeString(value_borderColor_value_0_2);
+            }
+            else if (value_borderColor_value_0_type == 3) {
+                valueSerializer.writeInt8(3);
+                const auto value_borderColor_value_0_3 = value_borderColor_value_0.value3;
+                Resource_serializer::write(valueSerializer, value_borderColor_value_0_3);
+            }
         }
-        else if (value_fontFamily_value_type == 1) {
+        else if (value_borderColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_fontFamily_value_1 = value_fontFamily_value.value1;
-            Resource_serializer::write(valueSerializer, value_fontFamily_value_1);
+            const auto value_borderColor_value_1 = value_borderColor_value.value1;
+            EdgeColors_serializer::write(valueSerializer, value_borderColor_value_1);
+        }
+        else if (value_borderColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_borderColor_value_2 = value_borderColor_value.value2;
+            LocalizedEdgeColors_serializer::write(valueSerializer, value_borderColor_value_2);
         }
     }
-    const auto value_decoration = value.decoration;
-    Ark_Int32 value_decoration_type = INTEROP_RUNTIME_UNDEFINED;
-    value_decoration_type = runtimeType(value_decoration);
-    valueSerializer.writeInt8(value_decoration_type);
-    if ((value_decoration_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_decoration_value = value_decoration.value;
-        DecorationStyleInterface_serializer::write(valueSerializer, value_decoration_value);
-    }
-    const auto value_textShadow = value.textShadow;
-    Ark_Int32 value_textShadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textShadow_type = runtimeType(value_textShadow);
-    valueSerializer.writeInt8(value_textShadow_type);
-    if ((value_textShadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textShadow_value = value_textShadow.value;
-        Ark_Int32 value_textShadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_textShadow_value_type = value_textShadow_value.selector;
-        if (value_textShadow_value_type == 0) {
+    const auto value_borderStyle = value.borderStyle;
+    Ark_Int32 value_borderStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_borderStyle_type = runtimeType(value_borderStyle);
+    valueSerializer.writeInt8(value_borderStyle_type);
+    if ((value_borderStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_borderStyle_value = value_borderStyle.value;
+        Ark_Int32 value_borderStyle_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_borderStyle_value_type = value_borderStyle_value.selector;
+        if (value_borderStyle_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_textShadow_value_0 = value_textShadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_0);
+            const auto value_borderStyle_value_0 = value_borderStyle_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_BorderStyle>(value_borderStyle_value_0));
         }
-        else if (value_textShadow_value_type == 1) {
+        else if (value_borderStyle_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_textShadow_value_1 = value_textShadow_value.value1;
-            valueSerializer.writeInt32(value_textShadow_value_1.length);
-            for (int value_textShadow_value_1_counter_i = 0; value_textShadow_value_1_counter_i < value_textShadow_value_1.length; value_textShadow_value_1_counter_i++) {
-                const Ark_ShadowOptions value_textShadow_value_1_element = value_textShadow_value_1.array[value_textShadow_value_1_counter_i];
-                ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_1_element);
-            }
+            const auto value_borderStyle_value_1 = value_borderStyle_value.value1;
+            EdgeStyles_serializer::write(valueSerializer, value_borderStyle_value_1);
         }
     }
-    const auto value_letterSpacing = value.letterSpacing;
-    Ark_Int32 value_letterSpacing_type = INTEROP_RUNTIME_UNDEFINED;
-    value_letterSpacing_type = runtimeType(value_letterSpacing);
-    valueSerializer.writeInt8(value_letterSpacing_type);
-    if ((value_letterSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_letterSpacing_value = value_letterSpacing.value;
-        Ark_Int32 value_letterSpacing_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_letterSpacing_value_type = value_letterSpacing_value.selector;
-        if (value_letterSpacing_value_type == 0) {
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_letterSpacing_value_0 = value_letterSpacing_value.value0;
-            valueSerializer.writeNumber(value_letterSpacing_value_0);
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
         }
-        else if (value_letterSpacing_value_type == 1) {
+        else if (value_shadow_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_letterSpacing_value_1 = value_letterSpacing_value.value1;
-            valueSerializer.writeString(value_letterSpacing_value_1);
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
     }
-    const auto value_lineHeight = value.lineHeight;
-    Ark_Int32 value_lineHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_lineHeight_type = runtimeType(value_lineHeight);
-    valueSerializer.writeInt8(value_lineHeight_type);
-    if ((value_lineHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_lineHeight_value = value_lineHeight.value;
-        Ark_Int32 value_lineHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_lineHeight_value_type = value_lineHeight_value.selector;
-        if (value_lineHeight_value_type == 0) {
+    const auto value_onHeightDidChange = value.onHeightDidChange;
+    Ark_Int32 value_onHeightDidChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onHeightDidChange_type = runtimeType(value_onHeightDidChange);
+    valueSerializer.writeInt8(value_onHeightDidChange_type);
+    if ((value_onHeightDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onHeightDidChange_value = value_onHeightDidChange.value;
+        valueSerializer.writeCallbackResource(value_onHeightDidChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHeightDidChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHeightDidChange_value.callSync));
+    }
+    const auto value_mode = value.mode;
+    Ark_Int32 value_mode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_mode_type = runtimeType(value_mode);
+    valueSerializer.writeInt8(value_mode_type);
+    if ((value_mode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_mode_value = value_mode.value;
+        valueSerializer.writeInt32(static_cast<Ark_SheetMode>(value_mode_value));
+    }
+    const auto value_scrollSizeMode = value.scrollSizeMode;
+    Ark_Int32 value_scrollSizeMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_scrollSizeMode_type = runtimeType(value_scrollSizeMode);
+    valueSerializer.writeInt8(value_scrollSizeMode_type);
+    if ((value_scrollSizeMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_scrollSizeMode_value = value_scrollSizeMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_ScrollSizeMode>(value_scrollSizeMode_value));
+    }
+    const auto value_onDetentsDidChange = value.onDetentsDidChange;
+    Ark_Int32 value_onDetentsDidChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDetentsDidChange_type = runtimeType(value_onDetentsDidChange);
+    valueSerializer.writeInt8(value_onDetentsDidChange_type);
+    if ((value_onDetentsDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDetentsDidChange_value = value_onDetentsDidChange.value;
+        valueSerializer.writeCallbackResource(value_onDetentsDidChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDetentsDidChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDetentsDidChange_value.callSync));
+    }
+    const auto value_onWidthDidChange = value.onWidthDidChange;
+    Ark_Int32 value_onWidthDidChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWidthDidChange_type = runtimeType(value_onWidthDidChange);
+    valueSerializer.writeInt8(value_onWidthDidChange_type);
+    if ((value_onWidthDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWidthDidChange_value = value_onWidthDidChange.value;
+        valueSerializer.writeCallbackResource(value_onWidthDidChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWidthDidChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWidthDidChange_value.callSync));
+    }
+    const auto value_onTypeDidChange = value.onTypeDidChange;
+    Ark_Int32 value_onTypeDidChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onTypeDidChange_type = runtimeType(value_onTypeDidChange);
+    valueSerializer.writeInt8(value_onTypeDidChange_type);
+    if ((value_onTypeDidChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onTypeDidChange_value = value_onTypeDidChange.value;
+        valueSerializer.writeCallbackResource(value_onTypeDidChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onTypeDidChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onTypeDidChange_value.callSync));
+    }
+    const auto value_uiContext = value.uiContext;
+    Ark_Int32 value_uiContext_type = INTEROP_RUNTIME_UNDEFINED;
+    value_uiContext_type = runtimeType(value_uiContext);
+    valueSerializer.writeInt8(value_uiContext_type);
+    if ((value_uiContext_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_uiContext_value = value_uiContext.value;
+        UIContext_serializer::write(valueSerializer, value_uiContext_value);
+    }
+    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
+    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
+    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
+    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_SheetKeyboardAvoidMode>(value_keyboardAvoidMode_value));
+    }
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHoverMode_value = value_enableHoverMode.value;
+        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    }
+    const auto value_hoverModeArea = value.hoverModeArea;
+    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
+    valueSerializer.writeInt8(value_hoverModeArea_type);
+    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hoverModeArea_value = value_hoverModeArea.value;
+        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
+    }
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Position_serializer::write(valueSerializer, value_offset_value);
+    }
+    const auto value_effectEdge = value.effectEdge;
+    Ark_Int32 value_effectEdge_type = INTEROP_RUNTIME_UNDEFINED;
+    value_effectEdge_type = runtimeType(value_effectEdge);
+    valueSerializer.writeInt8(value_effectEdge_type);
+    if ((value_effectEdge_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_effectEdge_value = value_effectEdge.value;
+        valueSerializer.writeNumber(value_effectEdge_value);
+    }
+    const auto value_radius = value.radius;
+    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_radius_type = runtimeType(value_radius);
+    valueSerializer.writeInt8(value_radius_type);
+    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_radius_value = value_radius.value;
+        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_radius_value_type = value_radius_value.selector;
+        if (value_radius_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_lineHeight_value_0 = value_lineHeight_value.value0;
-            valueSerializer.writeNumber(value_lineHeight_value_0);
+            const auto value_radius_value_0 = value_radius_value.value0;
+            LengthMetrics_serializer::write(valueSerializer, value_radius_value_0);
         }
-        else if (value_lineHeight_value_type == 1) {
+        else if (value_radius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_lineHeight_value_1 = value_lineHeight_value.value1;
-            valueSerializer.writeString(value_lineHeight_value_1);
+            const auto value_radius_value_1 = value_radius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_radius_value_1);
         }
-        else if (value_lineHeight_value_type == 2) {
+        else if (value_radius_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_lineHeight_value_2 = value_lineHeight_value.value2;
-            Resource_serializer::write(valueSerializer, value_lineHeight_value_2);
+            const auto value_radius_value_2 = value_radius_value.value2;
+            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_radius_value_2);
         }
     }
-    const auto value_halfLeading = value.halfLeading;
-    Ark_Int32 value_halfLeading_type = INTEROP_RUNTIME_UNDEFINED;
-    value_halfLeading_type = runtimeType(value_halfLeading);
-    valueSerializer.writeInt8(value_halfLeading_type);
-    if ((value_halfLeading_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_halfLeading_value = value_halfLeading.value;
-        valueSerializer.writeBoolean(value_halfLeading_value);
+    const auto value_detentSelection = value.detentSelection;
+    Ark_Int32 value_detentSelection_type = INTEROP_RUNTIME_UNDEFINED;
+    value_detentSelection_type = runtimeType(value_detentSelection);
+    valueSerializer.writeInt8(value_detentSelection_type);
+    if ((value_detentSelection_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_detentSelection_value = value_detentSelection.value;
+        Ark_Int32 value_detentSelection_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_detentSelection_value_type = value_detentSelection_value.selector;
+        if (value_detentSelection_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_detentSelection_value_0 = value_detentSelection_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_SheetSize>(value_detentSelection_value_0));
+        }
+        else if ((value_detentSelection_value_type == 1) || (value_detentSelection_value_type == 1) || (value_detentSelection_value_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value_detentSelection_value_1 = value_detentSelection_value.value1;
+            Ark_Int32 value_detentSelection_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_detentSelection_value_1_type = value_detentSelection_value_1.selector;
+            if (value_detentSelection_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_detentSelection_value_1_0 = value_detentSelection_value_1.value0;
+                valueSerializer.writeString(value_detentSelection_value_1_0);
+            }
+            else if (value_detentSelection_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_detentSelection_value_1_1 = value_detentSelection_value_1.value1;
+                valueSerializer.writeNumber(value_detentSelection_value_1_1);
+            }
+            else if (value_detentSelection_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_detentSelection_value_1_2 = value_detentSelection_value_1.value2;
+                Resource_serializer::write(valueSerializer, value_detentSelection_value_1_2);
+            }
+        }
     }
-    const auto value_fontFeature = value.fontFeature;
-    Ark_Int32 value_fontFeature_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontFeature_type = runtimeType(value_fontFeature);
-    valueSerializer.writeInt8(value_fontFeature_type);
-    if ((value_fontFeature_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontFeature_value = value_fontFeature.value;
-        valueSerializer.writeString(value_fontFeature_value);
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
     }
-    const auto value_textBackgroundStyle = value.textBackgroundStyle;
-    Ark_Int32 value_textBackgroundStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textBackgroundStyle_type = runtimeType(value_textBackgroundStyle);
-    valueSerializer.writeInt8(value_textBackgroundStyle_type);
-    if ((value_textBackgroundStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textBackgroundStyle_value = value_textBackgroundStyle.value;
-        TextBackgroundStyle_serializer::write(valueSerializer, value_textBackgroundStyle_value);
+    const auto value_placement = value.placement;
+    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placement_type = runtimeType(value_placement);
+    valueSerializer.writeInt8(value_placement_type);
+    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placement_value = value_placement.value;
+        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
+    }
+    const auto value_placementOnTarget = value.placementOnTarget;
+    Ark_Int32 value_placementOnTarget_type = INTEROP_RUNTIME_UNDEFINED;
+    value_placementOnTarget_type = runtimeType(value_placementOnTarget);
+    valueSerializer.writeInt8(value_placementOnTarget_type);
+    if ((value_placementOnTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_placementOnTarget_value = value_placementOnTarget.value;
+        valueSerializer.writeBoolean(value_placementOnTarget_value);
     }
 }
-inline Ark_RichEditorTextStyle RichEditorTextStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_SheetOptions SheetOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_RichEditorTextStyle value = {};
+    Ark_SheetOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor fontColor_buf = {};
-    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor fontColor_buf_ = {};
-        fontColor_buf_.selector = fontColor_buf__selector;
-        if (fontColor_buf__selector == 0) {
-            fontColor_buf_.selector = 0;
-            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (fontColor_buf__selector == 1) {
-            fontColor_buf_.selector = 1;
-            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (fontColor_buf__selector == 2) {
-            fontColor_buf_.selector = 2;
-            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (fontColor_buf__selector == 3) {
-            fontColor_buf_.selector = 3;
-            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
-    }
-    value.fontColor = fontColor_buf;
-    const auto fontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_String_Number_Resource fontSize_buf = {};
-    fontSize_buf.tag = fontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 fontSize_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_String_Number_Resource fontSize_buf_ = {};
-        fontSize_buf_.selector = fontSize_buf__selector;
-        if (fontSize_buf__selector == 0) {
-            fontSize_buf_.selector = 0;
-            fontSize_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (fontSize_buf__selector == 1) {
-            fontSize_buf_.selector = 1;
-            fontSize_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (fontSize_buf__selector == 2) {
-            fontSize_buf_.selector = 2;
-            fontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for fontSize_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
         }
-        fontSize_buf.value = static_cast<Ark_Union_String_Number_Resource>(fontSize_buf_);
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-    value.fontSize = fontSize_buf;
-    const auto fontStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_FontStyle fontStyle_buf = {};
-    fontStyle_buf.tag = fontStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundColor = backgroundColor_buf;
+    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onAppear_buf = {};
+    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        fontStyle_buf.value = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
+        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.fontStyle = fontStyle_buf;
-    const auto fontWeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_FontWeight_String fontWeight_buf = {};
-    fontWeight_buf.tag = fontWeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontWeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onAppear = onAppear_buf;
+    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDisappear_buf = {};
+    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontWeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_FontWeight_String fontWeight_buf_ = {};
-        fontWeight_buf_.selector = fontWeight_buf__selector;
-        if (fontWeight_buf__selector == 0) {
-            fontWeight_buf_.selector = 0;
-            fontWeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (fontWeight_buf__selector == 1) {
-            fontWeight_buf_.selector = 1;
-            fontWeight_buf_.value1 = static_cast<Ark_FontWeight>(valueDeserializer.readInt32());
-        }
-        else if (fontWeight_buf__selector == 2) {
-            fontWeight_buf_.selector = 2;
-            fontWeight_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.");
-        }
-        fontWeight_buf.value = static_cast<Ark_Union_Number_FontWeight_String>(fontWeight_buf_);
+        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.fontWeight = fontWeight_buf;
-    const auto fontFamily_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceStr fontFamily_buf = {};
-    fontFamily_buf.tag = fontFamily_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontFamily_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onDisappear = onDisappear_buf;
+    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillAppear_buf = {};
+    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 fontFamily_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceStr fontFamily_buf_ = {};
-        fontFamily_buf_.selector = fontFamily_buf__selector;
-        if (fontFamily_buf__selector == 0) {
-            fontFamily_buf_.selector = 0;
-            fontFamily_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (fontFamily_buf__selector == 1) {
-            fontFamily_buf_.selector = 1;
-            fontFamily_buf_.value1 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.");
-        }
-        fontFamily_buf.value = static_cast<Ark_ResourceStr>(fontFamily_buf_);
+        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.fontFamily = fontFamily_buf;
-    const auto decoration_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_DecorationStyleInterface decoration_buf = {};
-    decoration_buf.tag = decoration_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((decoration_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillAppear = onWillAppear_buf;
+    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillDisappear_buf = {};
+    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        decoration_buf.value = DecorationStyleInterface_serializer::read(valueDeserializer);
+        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    value.decoration = decoration_buf;
-    const auto textShadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_Array_ShadowOptions textShadow_buf = {};
-    textShadow_buf.tag = textShadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textShadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillDisappear = onWillDisappear_buf;
+    const auto height_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_SheetSize_Length height_buf = {};
+    height_buf.tag = height_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((height_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 textShadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_Array_ShadowOptions textShadow_buf_ = {};
-        textShadow_buf_.selector = textShadow_buf__selector;
-        if (textShadow_buf__selector == 0) {
-            textShadow_buf_.selector = 0;
-            textShadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        const Ark_Int8 height_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_SheetSize_Length height_buf_ = {};
+        height_buf_.selector = height_buf__selector;
+        if (height_buf__selector == 0) {
+            height_buf_.selector = 0;
+            height_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
         }
-        else if (textShadow_buf__selector == 1) {
-            textShadow_buf_.selector = 1;
-            const Ark_Int32 textShadow_buf__u_length = valueDeserializer.readInt32();
-            Array_ShadowOptions textShadow_buf__u = {};
-            valueDeserializer.resizeArray<std::decay<decltype(textShadow_buf__u)>::type,
-        std::decay<decltype(*textShadow_buf__u.array)>::type>(&textShadow_buf__u, textShadow_buf__u_length);
-            for (int textShadow_buf__u_i = 0; textShadow_buf__u_i < textShadow_buf__u_length; textShadow_buf__u_i++) {
-                textShadow_buf__u.array[textShadow_buf__u_i] = ShadowOptions_serializer::read(valueDeserializer);
+        else if (height_buf__selector == 1) {
+            height_buf_.selector = 1;
+            const Ark_Int8 height_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length height_buf__u = {};
+            height_buf__u.selector = height_buf__u_selector;
+            if (height_buf__u_selector == 0) {
+                height_buf__u.selector = 0;
+                height_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            textShadow_buf_.value1 = textShadow_buf__u;
+            else if (height_buf__u_selector == 1) {
+                height_buf__u.selector = 1;
+                height_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (height_buf__u_selector == 2) {
+                height_buf__u.selector = 2;
+                height_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for height_buf__u has to be chosen through deserialisation.");
+            }
+            height_buf_.value1 = static_cast<Ark_Length>(height_buf__u);
         }
         else {
-            INTEROP_FATAL("One of the branches for textShadow_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for height_buf_ has to be chosen through deserialisation.");
         }
-        textShadow_buf.value = static_cast<Ark_Union_ShadowOptions_Array_ShadowOptions>(textShadow_buf_);
+        height_buf.value = static_cast<Ark_Union_SheetSize_Length>(height_buf_);
     }
-    value.textShadow = textShadow_buf;
-    const auto letterSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_String letterSpacing_buf = {};
-    letterSpacing_buf.tag = letterSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((letterSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.height = height_buf;
+    const auto dragBar_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean dragBar_buf = {};
+    dragBar_buf.tag = dragBar_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((dragBar_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 letterSpacing_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_String letterSpacing_buf_ = {};
-        letterSpacing_buf_.selector = letterSpacing_buf__selector;
-        if (letterSpacing_buf__selector == 0) {
-            letterSpacing_buf_.selector = 0;
-            letterSpacing_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (letterSpacing_buf__selector == 1) {
-            letterSpacing_buf_.selector = 1;
-            letterSpacing_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for letterSpacing_buf_ has to be chosen through deserialisation.");
-        }
-        letterSpacing_buf.value = static_cast<Ark_Union_Number_String>(letterSpacing_buf_);
+        dragBar_buf.value = valueDeserializer.readBoolean();
     }
-    value.letterSpacing = letterSpacing_buf;
-    const auto lineHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_String_Resource lineHeight_buf = {};
-    lineHeight_buf.tag = lineHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((lineHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.dragBar = dragBar_buf;
+    const auto maskColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor maskColor_buf = {};
+    maskColor_buf.tag = maskColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maskColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 lineHeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_String_Resource lineHeight_buf_ = {};
-        lineHeight_buf_.selector = lineHeight_buf__selector;
-        if (lineHeight_buf__selector == 0) {
-            lineHeight_buf_.selector = 0;
-            lineHeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 maskColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor maskColor_buf_ = {};
+        maskColor_buf_.selector = maskColor_buf__selector;
+        if (maskColor_buf__selector == 0) {
+            maskColor_buf_.selector = 0;
+            maskColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (lineHeight_buf__selector == 1) {
-            lineHeight_buf_.selector = 1;
-            lineHeight_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (maskColor_buf__selector == 1) {
+            maskColor_buf_.selector = 1;
+            maskColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (lineHeight_buf__selector == 2) {
-            lineHeight_buf_.selector = 2;
-            lineHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (maskColor_buf__selector == 2) {
+            maskColor_buf_.selector = 2;
+            maskColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (maskColor_buf__selector == 3) {
+            maskColor_buf_.selector = 3;
+            maskColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for lineHeight_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for maskColor_buf_ has to be chosen through deserialisation.");
         }
-        lineHeight_buf.value = static_cast<Ark_Union_Number_String_Resource>(lineHeight_buf_);
-    }
-    value.lineHeight = lineHeight_buf;
-    const auto halfLeading_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean halfLeading_buf = {};
-    halfLeading_buf.tag = halfLeading_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((halfLeading_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        halfLeading_buf.value = valueDeserializer.readBoolean();
-    }
-    value.halfLeading = halfLeading_buf;
-    const auto fontFeature_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String fontFeature_buf = {};
-    fontFeature_buf.tag = fontFeature_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontFeature_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        fontFeature_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        maskColor_buf.value = static_cast<Ark_ResourceColor>(maskColor_buf_);
     }
-    value.fontFeature = fontFeature_buf;
-    const auto textBackgroundStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextBackgroundStyle textBackgroundStyle_buf = {};
-    textBackgroundStyle_buf.tag = textBackgroundStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textBackgroundStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maskColor = maskColor_buf;
+    const auto detents_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TripleLengthDetents detents_buf = {};
+    detents_buf.tag = detents_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((detents_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        textBackgroundStyle_buf.value = TextBackgroundStyle_serializer::read(valueDeserializer);
-    }
-    value.textBackgroundStyle = textBackgroundStyle_buf;
-    return value;
-}
-inline void RichEditorTextStyleResult_serializer::write(SerializerBase& buffer, Ark_RichEditorTextStyleResult value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_fontColor = value.fontColor;
-    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontColor_type = value_fontColor.selector;
-    if (value_fontColor_type == 0) {
-        valueSerializer.writeInt8(0);
-        const auto value_fontColor_0 = value_fontColor.value0;
-        valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_0));
+        Ark_TripleLengthDetents detents_buf_ = {};
+        const Ark_Int8 detents_buf__value0_buf_selector = valueDeserializer.readInt8();
+        Ark_Union_SheetSize_Length detents_buf__value0_buf = {};
+        detents_buf__value0_buf.selector = detents_buf__value0_buf_selector;
+        if (detents_buf__value0_buf_selector == 0) {
+            detents_buf__value0_buf.selector = 0;
+            detents_buf__value0_buf.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
+        }
+        else if (detents_buf__value0_buf_selector == 1) {
+            detents_buf__value0_buf.selector = 1;
+            const Ark_Int8 detents_buf__value0_buf_u_selector = valueDeserializer.readInt8();
+            Ark_Length detents_buf__value0_buf_u = {};
+            detents_buf__value0_buf_u.selector = detents_buf__value0_buf_u_selector;
+            if (detents_buf__value0_buf_u_selector == 0) {
+                detents_buf__value0_buf_u.selector = 0;
+                detents_buf__value0_buf_u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (detents_buf__value0_buf_u_selector == 1) {
+                detents_buf__value0_buf_u.selector = 1;
+                detents_buf__value0_buf_u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (detents_buf__value0_buf_u_selector == 2) {
+                detents_buf__value0_buf_u.selector = 2;
+                detents_buf__value0_buf_u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for detents_buf__value0_buf_u has to be chosen through deserialisation.");
+            }
+            detents_buf__value0_buf.value1 = static_cast<Ark_Length>(detents_buf__value0_buf_u);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for detents_buf__value0_buf has to be chosen through deserialisation.");
+        }
+        detents_buf_.value0 = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value0_buf);
+        const auto detents_buf__value1_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+        Opt_Union_SheetSize_Length detents_buf__value1_buf = {};
+        detents_buf__value1_buf.tag = detents_buf__value1_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((detents_buf__value1_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            const Ark_Int8 detents_buf__value1_buf__selector = valueDeserializer.readInt8();
+            Ark_Union_SheetSize_Length detents_buf__value1_buf_ = {};
+            detents_buf__value1_buf_.selector = detents_buf__value1_buf__selector;
+            if (detents_buf__value1_buf__selector == 0) {
+                detents_buf__value1_buf_.selector = 0;
+                detents_buf__value1_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
+            }
+            else if (detents_buf__value1_buf__selector == 1) {
+                detents_buf__value1_buf_.selector = 1;
+                const Ark_Int8 detents_buf__value1_buf__u_selector = valueDeserializer.readInt8();
+                Ark_Length detents_buf__value1_buf__u = {};
+                detents_buf__value1_buf__u.selector = detents_buf__value1_buf__u_selector;
+                if (detents_buf__value1_buf__u_selector == 0) {
+                    detents_buf__value1_buf__u.selector = 0;
+                    detents_buf__value1_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+                }
+                else if (detents_buf__value1_buf__u_selector == 1) {
+                    detents_buf__value1_buf__u.selector = 1;
+                    detents_buf__value1_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+                }
+                else if (detents_buf__value1_buf__u_selector == 2) {
+                    detents_buf__value1_buf__u.selector = 2;
+                    detents_buf__value1_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+                }
+                else {
+                    INTEROP_FATAL("One of the branches for detents_buf__value1_buf__u has to be chosen through deserialisation.");
+                }
+                detents_buf__value1_buf_.value1 = static_cast<Ark_Length>(detents_buf__value1_buf__u);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for detents_buf__value1_buf_ has to be chosen through deserialisation.");
+            }
+            detents_buf__value1_buf.value = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value1_buf_);
+        }
+        detents_buf_.value1 = detents_buf__value1_buf;
+        const auto detents_buf__value2_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+        Opt_Union_SheetSize_Length detents_buf__value2_buf = {};
+        detents_buf__value2_buf.tag = detents_buf__value2_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((detents_buf__value2_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            const Ark_Int8 detents_buf__value2_buf__selector = valueDeserializer.readInt8();
+            Ark_Union_SheetSize_Length detents_buf__value2_buf_ = {};
+            detents_buf__value2_buf_.selector = detents_buf__value2_buf__selector;
+            if (detents_buf__value2_buf__selector == 0) {
+                detents_buf__value2_buf_.selector = 0;
+                detents_buf__value2_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
+            }
+            else if (detents_buf__value2_buf__selector == 1) {
+                detents_buf__value2_buf_.selector = 1;
+                const Ark_Int8 detents_buf__value2_buf__u_selector = valueDeserializer.readInt8();
+                Ark_Length detents_buf__value2_buf__u = {};
+                detents_buf__value2_buf__u.selector = detents_buf__value2_buf__u_selector;
+                if (detents_buf__value2_buf__u_selector == 0) {
+                    detents_buf__value2_buf__u.selector = 0;
+                    detents_buf__value2_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+                }
+                else if (detents_buf__value2_buf__u_selector == 1) {
+                    detents_buf__value2_buf__u.selector = 1;
+                    detents_buf__value2_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+                }
+                else if (detents_buf__value2_buf__u_selector == 2) {
+                    detents_buf__value2_buf__u.selector = 2;
+                    detents_buf__value2_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+                }
+                else {
+                    INTEROP_FATAL("One of the branches for detents_buf__value2_buf__u has to be chosen through deserialisation.");
+                }
+                detents_buf__value2_buf_.value1 = static_cast<Ark_Length>(detents_buf__value2_buf__u);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for detents_buf__value2_buf_ has to be chosen through deserialisation.");
+            }
+            detents_buf__value2_buf.value = static_cast<Ark_Union_SheetSize_Length>(detents_buf__value2_buf_);
+        }
+        detents_buf_.value2 = detents_buf__value2_buf;
+        detents_buf.value = detents_buf_;
     }
-    else if (value_fontColor_type == 1) {
-        valueSerializer.writeInt8(1);
-        const auto value_fontColor_1 = value_fontColor.value1;
-        valueSerializer.writeNumber(value_fontColor_1);
+    value.detents = detents_buf;
+    const auto blurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle blurStyle_buf = {};
+    blurStyle_buf.tag = blurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((blurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        blurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    else if (value_fontColor_type == 2) {
-        valueSerializer.writeInt8(2);
-        const auto value_fontColor_2 = value_fontColor.value2;
-        valueSerializer.writeString(value_fontColor_2);
+    value.blurStyle = blurStyle_buf;
+    const auto showClose_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_Resource showClose_buf = {};
+    showClose_buf.tag = showClose_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showClose_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 showClose_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_Resource showClose_buf_ = {};
+        showClose_buf_.selector = showClose_buf__selector;
+        if (showClose_buf__selector == 0) {
+            showClose_buf_.selector = 0;
+            showClose_buf_.value0 = valueDeserializer.readBoolean();
+        }
+        else if (showClose_buf__selector == 1) {
+            showClose_buf_.selector = 1;
+            showClose_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for showClose_buf_ has to be chosen through deserialisation.");
+        }
+        showClose_buf.value = static_cast<Ark_Union_Boolean_Resource>(showClose_buf_);
     }
-    else if (value_fontColor_type == 3) {
-        valueSerializer.writeInt8(3);
-        const auto value_fontColor_3 = value_fontColor.value3;
-        Resource_serializer::write(valueSerializer, value_fontColor_3);
+    value.showClose = showClose_buf;
+    const auto preferType_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SheetType preferType_buf = {};
+    preferType_buf.tag = preferType_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((preferType_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        preferType_buf.value = static_cast<Ark_SheetType>(valueDeserializer.readInt32());
     }
-    const auto value_fontSize = value.fontSize;
-    valueSerializer.writeNumber(value_fontSize);
-    const auto value_fontStyle = value.fontStyle;
-    valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle));
-    const auto value_fontWeight = value.fontWeight;
-    valueSerializer.writeNumber(value_fontWeight);
-    const auto value_fontFamily = value.fontFamily;
-    valueSerializer.writeString(value_fontFamily);
-    const auto value_decoration = value.decoration;
-    DecorationStyleResult_serializer::write(valueSerializer, value_decoration);
-    const auto value_textShadow = value.textShadow;
-    Ark_Int32 value_textShadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textShadow_type = runtimeType(value_textShadow);
-    valueSerializer.writeInt8(value_textShadow_type);
-    if ((value_textShadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textShadow_value = value_textShadow.value;
-        valueSerializer.writeInt32(value_textShadow_value.length);
-        for (int value_textShadow_value_counter_i = 0; value_textShadow_value_counter_i < value_textShadow_value.length; value_textShadow_value_counter_i++) {
-            const Ark_ShadowOptions value_textShadow_value_element = value_textShadow_value.array[value_textShadow_value_counter_i];
-            ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_element);
+    value.preferType = preferType_buf;
+    const auto title_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_SheetTitleOptions_CustomBuilder title_buf = {};
+    title_buf.tag = title_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((title_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 title_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_SheetTitleOptions_CustomBuilder title_buf_ = {};
+        title_buf_.selector = title_buf__selector;
+        if (title_buf__selector == 0) {
+            title_buf_.selector = 0;
+            title_buf_.value0 = SheetTitleOptions_serializer::read(valueDeserializer);
+        }
+        else if (title_buf__selector == 1) {
+            title_buf_.selector = 1;
+            title_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
         }
+        else {
+            INTEROP_FATAL("One of the branches for title_buf_ has to be chosen through deserialisation.");
+        }
+        title_buf.value = static_cast<Ark_Union_SheetTitleOptions_CustomBuilder>(title_buf_);
     }
-    const auto value_letterSpacing = value.letterSpacing;
-    Ark_Int32 value_letterSpacing_type = INTEROP_RUNTIME_UNDEFINED;
-    value_letterSpacing_type = runtimeType(value_letterSpacing);
-    valueSerializer.writeInt8(value_letterSpacing_type);
-    if ((value_letterSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_letterSpacing_value = value_letterSpacing.value;
-        valueSerializer.writeNumber(value_letterSpacing_value);
+    value.title = title_buf;
+    const auto shouldDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_SheetDismiss_Void shouldDismiss_buf = {};
+    shouldDismiss_buf.tag = shouldDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shouldDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        shouldDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_SheetDismiss sheetDismiss)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SheetDismiss_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_SheetDismiss sheetDismiss)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SheetDismiss_Void))))};
     }
-    const auto value_lineHeight = value.lineHeight;
-    Ark_Int32 value_lineHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_lineHeight_type = runtimeType(value_lineHeight);
-    valueSerializer.writeInt8(value_lineHeight_type);
-    if ((value_lineHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_lineHeight_value = value_lineHeight.value;
-        valueSerializer.writeNumber(value_lineHeight_value);
+    value.shouldDismiss = shouldDismiss_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_DismissSheetAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissSheetAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissSheetAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissSheetAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissSheetAction_Void))))};
     }
-    const auto value_halfLeading = value.halfLeading;
-    Ark_Int32 value_halfLeading_type = INTEROP_RUNTIME_UNDEFINED;
-    value_halfLeading_type = runtimeType(value_halfLeading);
-    valueSerializer.writeInt8(value_halfLeading_type);
-    if ((value_halfLeading_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_halfLeading_value = value_halfLeading.value;
-        valueSerializer.writeBoolean(value_halfLeading_value);
+    value.onWillDismiss = onWillDismiss_buf;
+    const auto onWillSpringBackWhenDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_SpringBackAction_Void onWillSpringBackWhenDismiss_buf = {};
+    onWillSpringBackWhenDismiss_buf.tag = onWillSpringBackWhenDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillSpringBackWhenDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillSpringBackWhenDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_SpringBackAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SpringBackAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_SpringBackAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SpringBackAction_Void))))};
     }
-    const auto value_fontFeature = value.fontFeature;
-    Ark_Int32 value_fontFeature_type = INTEROP_RUNTIME_UNDEFINED;
-    value_fontFeature_type = runtimeType(value_fontFeature);
-    valueSerializer.writeInt8(value_fontFeature_type);
-    if ((value_fontFeature_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_fontFeature_value = value_fontFeature.value;
-        valueSerializer.writeString(value_fontFeature_value);
+    value.onWillSpringBackWhenDismiss = onWillSpringBackWhenDismiss_buf;
+    const auto enableOutsideInteractive_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableOutsideInteractive_buf = {};
+    enableOutsideInteractive_buf.tag = enableOutsideInteractive_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableOutsideInteractive_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableOutsideInteractive_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_textBackgroundStyle = value.textBackgroundStyle;
-    Ark_Int32 value_textBackgroundStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_textBackgroundStyle_type = runtimeType(value_textBackgroundStyle);
-    valueSerializer.writeInt8(value_textBackgroundStyle_type);
-    if ((value_textBackgroundStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_textBackgroundStyle_value = value_textBackgroundStyle.value;
-        TextBackgroundStyle_serializer::write(valueSerializer, value_textBackgroundStyle_value);
+    value.enableOutsideInteractive = enableOutsideInteractive_buf;
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension width_buf_ = {};
+        width_buf_.selector = width_buf__selector;
+        if (width_buf__selector == 0) {
+            width_buf_.selector = 0;
+            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (width_buf__selector == 2) {
+            width_buf_.selector = 2;
+            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+        }
+        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
     }
-}
-inline Ark_RichEditorTextStyleResult RichEditorTextStyleResult_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorTextStyleResult value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const Ark_Int8 fontColor_buf_selector = valueDeserializer.readInt8();
-    Ark_ResourceColor fontColor_buf = {};
-    fontColor_buf.selector = fontColor_buf_selector;
-    if (fontColor_buf_selector == 0) {
-        fontColor_buf.selector = 0;
-        fontColor_buf.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+    value.width = width_buf;
+    const auto borderWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_EdgeWidths_LocalizedEdgeWidths borderWidth_buf = {};
+    borderWidth_buf.tag = borderWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_EdgeWidths_LocalizedEdgeWidths borderWidth_buf_ = {};
+        borderWidth_buf_.selector = borderWidth_buf__selector;
+        if (borderWidth_buf__selector == 0) {
+            borderWidth_buf_.selector = 0;
+            const Ark_Int8 borderWidth_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension borderWidth_buf__u = {};
+            borderWidth_buf__u.selector = borderWidth_buf__u_selector;
+            if (borderWidth_buf__u_selector == 0) {
+                borderWidth_buf__u.selector = 0;
+                borderWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderWidth_buf__u_selector == 1) {
+                borderWidth_buf__u.selector = 1;
+                borderWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderWidth_buf__u_selector == 2) {
+                borderWidth_buf__u.selector = 2;
+                borderWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for borderWidth_buf__u has to be chosen through deserialisation.");
+            }
+            borderWidth_buf_.value0 = static_cast<Ark_Dimension>(borderWidth_buf__u);
+        }
+        else if (borderWidth_buf__selector == 1) {
+            borderWidth_buf_.selector = 1;
+            borderWidth_buf_.value1 = EdgeWidths_serializer::read(valueDeserializer);
+        }
+        else if (borderWidth_buf__selector == 2) {
+            borderWidth_buf_.selector = 2;
+            borderWidth_buf_.value2 = LocalizedEdgeWidths_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for borderWidth_buf_ has to be chosen through deserialisation.");
+        }
+        borderWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeWidths_LocalizedEdgeWidths>(borderWidth_buf_);
     }
-    else if (fontColor_buf_selector == 1) {
-        fontColor_buf.selector = 1;
-        fontColor_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.borderWidth = borderWidth_buf;
+    const auto borderColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceColor_EdgeColors_LocalizedEdgeColors borderColor_buf = {};
+    borderColor_buf.tag = borderColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceColor_EdgeColors_LocalizedEdgeColors borderColor_buf_ = {};
+        borderColor_buf_.selector = borderColor_buf__selector;
+        if (borderColor_buf__selector == 0) {
+            borderColor_buf_.selector = 0;
+            const Ark_Int8 borderColor_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceColor borderColor_buf__u = {};
+            borderColor_buf__u.selector = borderColor_buf__u_selector;
+            if (borderColor_buf__u_selector == 0) {
+                borderColor_buf__u.selector = 0;
+                borderColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+            }
+            else if (borderColor_buf__u_selector == 1) {
+                borderColor_buf__u.selector = 1;
+                borderColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (borderColor_buf__u_selector == 2) {
+                borderColor_buf__u.selector = 2;
+                borderColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (borderColor_buf__u_selector == 3) {
+                borderColor_buf__u.selector = 3;
+                borderColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for borderColor_buf__u has to be chosen through deserialisation.");
+            }
+            borderColor_buf_.value0 = static_cast<Ark_ResourceColor>(borderColor_buf__u);
+        }
+        else if (borderColor_buf__selector == 1) {
+            borderColor_buf_.selector = 1;
+            borderColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
+        }
+        else if (borderColor_buf__selector == 2) {
+            borderColor_buf_.selector = 2;
+            borderColor_buf_.value2 = LocalizedEdgeColors_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for borderColor_buf_ has to be chosen through deserialisation.");
+        }
+        borderColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors_LocalizedEdgeColors>(borderColor_buf_);
     }
-    else if (fontColor_buf_selector == 2) {
-        fontColor_buf.selector = 2;
-        fontColor_buf.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    value.borderColor = borderColor_buf;
+    const auto borderStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_BorderStyle_EdgeStyles borderStyle_buf = {};
+    borderStyle_buf.tag = borderStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((borderStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 borderStyle_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_BorderStyle_EdgeStyles borderStyle_buf_ = {};
+        borderStyle_buf_.selector = borderStyle_buf__selector;
+        if (borderStyle_buf__selector == 0) {
+            borderStyle_buf_.selector = 0;
+            borderStyle_buf_.value0 = static_cast<Ark_BorderStyle>(valueDeserializer.readInt32());
+        }
+        else if (borderStyle_buf__selector == 1) {
+            borderStyle_buf_.selector = 1;
+            borderStyle_buf_.value1 = EdgeStyles_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for borderStyle_buf_ has to be chosen through deserialisation.");
+        }
+        borderStyle_buf.value = static_cast<Ark_Union_BorderStyle_EdgeStyles>(borderStyle_buf_);
     }
-    else if (fontColor_buf_selector == 3) {
-        fontColor_buf.selector = 3;
-        fontColor_buf.value3 = Resource_serializer::read(valueDeserializer);
+    value.borderStyle = borderStyle_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        }
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+        }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
-    else {
-        INTEROP_FATAL("One of the branches for fontColor_buf has to be chosen through deserialisation.");
+    value.shadow = shadow_buf;
+    const auto onHeightDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Number_Void onHeightDidChange_buf = {};
+    onHeightDidChange_buf.tag = onHeightDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onHeightDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onHeightDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
     }
-    value.fontColor = static_cast<Ark_ResourceColor>(fontColor_buf);
-    value.fontSize = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.fontStyle = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
-    value.fontWeight = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.fontFamily = static_cast<Ark_String>(valueDeserializer.readString());
-    value.decoration = DecorationStyleResult_serializer::read(valueDeserializer);
-    const auto textShadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Array_ShadowOptions textShadow_buf = {};
-    textShadow_buf.tag = textShadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textShadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onHeightDidChange = onHeightDidChange_buf;
+    const auto mode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SheetMode mode_buf = {};
+    mode_buf.tag = mode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((mode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int32 textShadow_buf__length = valueDeserializer.readInt32();
-        Array_ShadowOptions textShadow_buf_ = {};
-        valueDeserializer.resizeArray<std::decay<decltype(textShadow_buf_)>::type,
-        std::decay<decltype(*textShadow_buf_.array)>::type>(&textShadow_buf_, textShadow_buf__length);
-        for (int textShadow_buf__i = 0; textShadow_buf__i < textShadow_buf__length; textShadow_buf__i++) {
-            textShadow_buf_.array[textShadow_buf__i] = ShadowOptions_serializer::read(valueDeserializer);
-        }
-        textShadow_buf.value = textShadow_buf_;
+        mode_buf.value = static_cast<Ark_SheetMode>(valueDeserializer.readInt32());
     }
-    value.textShadow = textShadow_buf;
-    const auto letterSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number letterSpacing_buf = {};
-    letterSpacing_buf.tag = letterSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((letterSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.mode = mode_buf;
+    const auto scrollSizeMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ScrollSizeMode scrollSizeMode_buf = {};
+    scrollSizeMode_buf.tag = scrollSizeMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((scrollSizeMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        letterSpacing_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        scrollSizeMode_buf.value = static_cast<Ark_ScrollSizeMode>(valueDeserializer.readInt32());
     }
-    value.letterSpacing = letterSpacing_buf;
-    const auto lineHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number lineHeight_buf = {};
-    lineHeight_buf.tag = lineHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((lineHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.scrollSizeMode = scrollSizeMode_buf;
+    const auto onDetentsDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Number_Void onDetentsDidChange_buf = {};
+    onDetentsDidChange_buf.tag = onDetentsDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDetentsDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        lineHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        onDetentsDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
     }
-    value.lineHeight = lineHeight_buf;
-    const auto halfLeading_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean halfLeading_buf = {};
-    halfLeading_buf.tag = halfLeading_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((halfLeading_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onDetentsDidChange = onDetentsDidChange_buf;
+    const auto onWidthDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Number_Void onWidthDidChange_buf = {};
+    onWidthDidChange_buf.tag = onWidthDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWidthDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        halfLeading_buf.value = valueDeserializer.readBoolean();
+        onWidthDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
     }
-    value.halfLeading = halfLeading_buf;
-    const auto fontFeature_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String fontFeature_buf = {};
-    fontFeature_buf.tag = fontFeature_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((fontFeature_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWidthDidChange = onWidthDidChange_buf;
+    const auto onTypeDidChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_SheetType_Void onTypeDidChange_buf = {};
+    onTypeDidChange_buf.tag = onTypeDidChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onTypeDidChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        fontFeature_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        onTypeDidChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, Ark_SheetType value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_SheetType_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, Ark_SheetType value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_SheetType_Void))))};
     }
-    value.fontFeature = fontFeature_buf;
-    const auto textBackgroundStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextBackgroundStyle textBackgroundStyle_buf = {};
-    textBackgroundStyle_buf.tag = textBackgroundStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textBackgroundStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onTypeDidChange = onTypeDidChange_buf;
+    const auto uiContext_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_UIContext uiContext_buf = {};
+    uiContext_buf.tag = uiContext_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((uiContext_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        textBackgroundStyle_buf.value = TextBackgroundStyle_serializer::read(valueDeserializer);
+        uiContext_buf.value = static_cast<Ark_UIContext>(UIContext_serializer::read(valueDeserializer));
     }
-    value.textBackgroundStyle = textBackgroundStyle_buf;
-    return value;
-}
-inline void RichEditorUpdateImageSpanStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorUpdateImageSpanStyleOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_start = value.start;
-    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
-    value_start_type = runtimeType(value_start);
-    valueSerializer.writeInt8(value_start_type);
-    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_start_value = value_start.value;
-        valueSerializer.writeNumber(value_start_value);
+    value.uiContext = uiContext_buf;
+    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SheetKeyboardAvoidMode keyboardAvoidMode_buf = {};
+    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        keyboardAvoidMode_buf.value = static_cast<Ark_SheetKeyboardAvoidMode>(valueDeserializer.readInt32());
     }
-    const auto value_end = value.end;
-    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
-    value_end_type = runtimeType(value_end);
-    valueSerializer.writeInt8(value_end_type);
-    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_end_value = value_end.value;
-        valueSerializer.writeNumber(value_end_value);
+    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_imageStyle = value.imageStyle;
-    RichEditorImageSpanStyle_serializer::write(valueSerializer, value_imageStyle);
-}
-inline Ark_RichEditorUpdateImageSpanStyleOptions RichEditorUpdateImageSpanStyleOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorUpdateImageSpanStyleOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HoverModeAreaType hoverModeArea_buf = {};
+    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
     }
-    value.start = start_buf;
-    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number end_buf = {};
-    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.hoverModeArea = hoverModeArea_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        offset_buf.value = Position_serializer::read(valueDeserializer);
     }
-    value.end = end_buf;
-    value.imageStyle = RichEditorImageSpanStyle_serializer::read(valueDeserializer);
-    return value;
-}
-inline void RichEditorUpdateTextSpanStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorUpdateTextSpanStyleOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_start = value.start;
-    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
-    value_start_type = runtimeType(value_start);
-    valueSerializer.writeInt8(value_start_type);
-    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_start_value = value_start.value;
-        valueSerializer.writeNumber(value_start_value);
+    value.offset = offset_buf;
+    const auto effectEdge_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number effectEdge_buf = {};
+    effectEdge_buf.tag = effectEdge_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((effectEdge_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        effectEdge_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_end = value.end;
-    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
-    value_end_type = runtimeType(value_end);
-    valueSerializer.writeInt8(value_end_type);
-    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_end_value = value_end.value;
-        valueSerializer.writeNumber(value_end_value);
+    value.effectEdge = effectEdge_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            radius_buf_.value0 = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        }
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            radius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        }
+        else if (radius_buf__selector == 2) {
+            radius_buf_.selector = 2;
+            radius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+        }
+        radius_buf.value = static_cast<Ark_Union_LengthMetrics_BorderRadiuses_LocalizedBorderRadiuses>(radius_buf_);
     }
-    const auto value_textStyle = value.textStyle;
-    RichEditorTextStyle_serializer::write(valueSerializer, value_textStyle);
-    const auto value_urlStyle = value.urlStyle;
-    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_urlStyle_type = runtimeType(value_urlStyle);
-    valueSerializer.writeInt8(value_urlStyle_type);
-    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_urlStyle_value = value_urlStyle.value;
-        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
+    value.radius = radius_buf;
+    const auto detentSelection_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_SheetSize_Length detentSelection_buf = {};
+    detentSelection_buf.tag = detentSelection_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((detentSelection_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 detentSelection_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_SheetSize_Length detentSelection_buf_ = {};
+        detentSelection_buf_.selector = detentSelection_buf__selector;
+        if (detentSelection_buf__selector == 0) {
+            detentSelection_buf_.selector = 0;
+            detentSelection_buf_.value0 = static_cast<Ark_SheetSize>(valueDeserializer.readInt32());
+        }
+        else if (detentSelection_buf__selector == 1) {
+            detentSelection_buf_.selector = 1;
+            const Ark_Int8 detentSelection_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length detentSelection_buf__u = {};
+            detentSelection_buf__u.selector = detentSelection_buf__u_selector;
+            if (detentSelection_buf__u_selector == 0) {
+                detentSelection_buf__u.selector = 0;
+                detentSelection_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (detentSelection_buf__u_selector == 1) {
+                detentSelection_buf__u.selector = 1;
+                detentSelection_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (detentSelection_buf__u_selector == 2) {
+                detentSelection_buf__u.selector = 2;
+                detentSelection_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for detentSelection_buf__u has to be chosen through deserialisation.");
+            }
+            detentSelection_buf_.value1 = static_cast<Ark_Length>(detentSelection_buf__u);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for detentSelection_buf_ has to be chosen through deserialisation.");
+        }
+        detentSelection_buf.value = static_cast<Ark_Union_SheetSize_Length>(detentSelection_buf_);
     }
-}
-inline Ark_RichEditorUpdateTextSpanStyleOptions RichEditorUpdateTextSpanStyleOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorUpdateTextSpanStyleOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.detentSelection = detentSelection_buf;
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
     }
-    value.start = start_buf;
-    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number end_buf = {};
-    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.showInSubWindow = showInSubWindow_buf;
+    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Placement placement_buf = {};
+    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
     }
-    value.end = end_buf;
-    value.textStyle = RichEditorTextStyle_serializer::read(valueDeserializer);
-    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorUrlStyle urlStyle_buf = {};
-    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.placement = placement_buf;
+    const auto placementOnTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean placementOnTarget_buf = {};
+    placementOnTarget_buf.tag = placementOnTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((placementOnTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
+        placementOnTarget_buf.value = valueDeserializer.readBoolean();
     }
-    value.urlStyle = urlStyle_buf;
+    value.placementOnTarget = placementOnTarget_buf;
     return value;
 }
-inline void StyleOptions_serializer::write(SerializerBase& buffer, Ark_StyleOptions value)
+inline void SwipeActionOptions_serializer::write(SerializerBase& buffer, Ark_SwipeActionOptions value)
 {
     SerializerBase& valueSerializer = buffer;
     const auto value_start = value.start;
@@ -112814,2075 +114989,2266 @@ inline void StyleOptions_serializer::write(SerializerBase& buffer, Ark_StyleOpti
     valueSerializer.writeInt8(value_start_type);
     if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
         const auto value_start_value = value_start.value;
-        valueSerializer.writeNumber(value_start_value);
-    }
-    const auto value_length = value.length;
-    Ark_Int32 value_length_type = INTEROP_RUNTIME_UNDEFINED;
-    value_length_type = runtimeType(value_length);
-    valueSerializer.writeInt8(value_length_type);
-    if ((value_length_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_length_value = value_length.value;
-        valueSerializer.writeNumber(value_length_value);
-    }
-    const auto value_styledKey = value.styledKey;
-    valueSerializer.writeInt32(static_cast<Ark_StyledStringKey>(value_styledKey));
-    const auto value_styledValue = value.styledValue;
-    Ark_Int32 value_styledValue_type = INTEROP_RUNTIME_UNDEFINED;
-    value_styledValue_type = value_styledValue.selector;
-    if (value_styledValue_type == 0) {
-        valueSerializer.writeInt8(0);
-        const auto value_styledValue_0 = value_styledValue.value0;
-        TextStyle_serializer::write(valueSerializer, value_styledValue_0);
-    }
-    else if (value_styledValue_type == 1) {
-        valueSerializer.writeInt8(1);
-        const auto value_styledValue_1 = value_styledValue.value1;
-        DecorationStyle_serializer::write(valueSerializer, value_styledValue_1);
-    }
-    else if (value_styledValue_type == 2) {
-        valueSerializer.writeInt8(2);
-        const auto value_styledValue_2 = value_styledValue.value2;
-        BaselineOffsetStyle_serializer::write(valueSerializer, value_styledValue_2);
-    }
-    else if (value_styledValue_type == 3) {
-        valueSerializer.writeInt8(3);
-        const auto value_styledValue_3 = value_styledValue.value3;
-        LetterSpacingStyle_serializer::write(valueSerializer, value_styledValue_3);
-    }
-    else if (value_styledValue_type == 4) {
-        valueSerializer.writeInt8(4);
-        const auto value_styledValue_4 = value_styledValue.value4;
-        TextShadowStyle_serializer::write(valueSerializer, value_styledValue_4);
-    }
-    else if (value_styledValue_type == 5) {
-        valueSerializer.writeInt8(5);
-        const auto value_styledValue_5 = value_styledValue.value5;
-        GestureStyle_serializer::write(valueSerializer, value_styledValue_5);
-    }
-    else if (value_styledValue_type == 6) {
-        valueSerializer.writeInt8(6);
-        const auto value_styledValue_6 = value_styledValue.value6;
-        ImageAttachment_serializer::write(valueSerializer, value_styledValue_6);
-    }
-    else if (value_styledValue_type == 7) {
-        valueSerializer.writeInt8(7);
-        const auto value_styledValue_7 = value_styledValue.value7;
-        ParagraphStyle_serializer::write(valueSerializer, value_styledValue_7);
-    }
-    else if (value_styledValue_type == 8) {
-        valueSerializer.writeInt8(8);
-        const auto value_styledValue_8 = value_styledValue.value8;
-        LineHeightStyle_serializer::write(valueSerializer, value_styledValue_8);
-    }
-    else if (value_styledValue_type == 9) {
-        valueSerializer.writeInt8(9);
-        const auto value_styledValue_9 = value_styledValue.value9;
-        UrlStyle_serializer::write(valueSerializer, value_styledValue_9);
-    }
-    else if (value_styledValue_type == 10) {
-        valueSerializer.writeInt8(10);
-        const auto value_styledValue_10 = value_styledValue.value10;
-        CustomSpan_serializer::write(valueSerializer, value_styledValue_10);
-    }
-    else if (value_styledValue_type == 11) {
-        valueSerializer.writeInt8(11);
-        const auto value_styledValue_11 = value_styledValue.value11;
-        UserDataSpan_serializer::write(valueSerializer, value_styledValue_11);
-    }
-    else if (value_styledValue_type == 12) {
-        valueSerializer.writeInt8(12);
-        const auto value_styledValue_12 = value_styledValue.value12;
-        BackgroundColorStyle_serializer::write(valueSerializer, value_styledValue_12);
-    }
-}
-inline Ark_StyleOptions StyleOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_StyleOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number start_buf = {};
-    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.start = start_buf;
-    const auto length_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number length_buf = {};
-    length_buf.tag = length_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((length_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        length_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    }
-    value.length = length_buf;
-    value.styledKey = static_cast<Ark_StyledStringKey>(valueDeserializer.readInt32());
-    const Ark_Int8 styledValue_buf_selector = valueDeserializer.readInt8();
-    Ark_StyledStringValue styledValue_buf = {};
-    styledValue_buf.selector = styledValue_buf_selector;
-    if (styledValue_buf_selector == 0) {
-        styledValue_buf.selector = 0;
-        styledValue_buf.value0 = static_cast<Ark_TextStyle>(TextStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 1) {
-        styledValue_buf.selector = 1;
-        styledValue_buf.value1 = static_cast<Ark_DecorationStyle>(DecorationStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 2) {
-        styledValue_buf.selector = 2;
-        styledValue_buf.value2 = static_cast<Ark_BaselineOffsetStyle>(BaselineOffsetStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 3) {
-        styledValue_buf.selector = 3;
-        styledValue_buf.value3 = static_cast<Ark_LetterSpacingStyle>(LetterSpacingStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 4) {
-        styledValue_buf.selector = 4;
-        styledValue_buf.value4 = static_cast<Ark_TextShadowStyle>(TextShadowStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 5) {
-        styledValue_buf.selector = 5;
-        styledValue_buf.value5 = static_cast<Ark_GestureStyle>(GestureStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 6) {
-        styledValue_buf.selector = 6;
-        styledValue_buf.value6 = static_cast<Ark_ImageAttachment>(ImageAttachment_serializer::read(valueDeserializer));
+        Ark_Int32 value_start_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_start_value_type = value_start_value.selector;
+        if (value_start_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_start_value_0 = value_start_value.value0;
+            valueSerializer.writeCallbackResource(value_start_value_0.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_start_value_0.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_start_value_0.callSync));
+        }
+        else if (value_start_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_start_value_1 = value_start_value.value1;
+            SwipeActionItem_serializer::write(valueSerializer, value_start_value_1);
+        }
     }
-    else if (styledValue_buf_selector == 7) {
-        styledValue_buf.selector = 7;
-        styledValue_buf.value7 = static_cast<Ark_ParagraphStyle>(ParagraphStyle_serializer::read(valueDeserializer));
+    const auto value_end = value.end;
+    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
+    value_end_type = runtimeType(value_end);
+    valueSerializer.writeInt8(value_end_type);
+    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_end_value = value_end.value;
+        Ark_Int32 value_end_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_end_value_type = value_end_value.selector;
+        if (value_end_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_end_value_0 = value_end_value.value0;
+            valueSerializer.writeCallbackResource(value_end_value_0.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_end_value_0.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_end_value_0.callSync));
+        }
+        else if (value_end_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_end_value_1 = value_end_value.value1;
+            SwipeActionItem_serializer::write(valueSerializer, value_end_value_1);
+        }
     }
-    else if (styledValue_buf_selector == 8) {
-        styledValue_buf.selector = 8;
-        styledValue_buf.value8 = static_cast<Ark_LineHeightStyle>(LineHeightStyle_serializer::read(valueDeserializer));
+    const auto value_edgeEffect = value.edgeEffect;
+    Ark_Int32 value_edgeEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_edgeEffect_type = runtimeType(value_edgeEffect);
+    valueSerializer.writeInt8(value_edgeEffect_type);
+    if ((value_edgeEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_edgeEffect_value = value_edgeEffect.value;
+        valueSerializer.writeInt32(static_cast<Ark_SwipeEdgeEffect>(value_edgeEffect_value));
     }
-    else if (styledValue_buf_selector == 9) {
-        styledValue_buf.selector = 9;
-        styledValue_buf.value9 = static_cast<Ark_UrlStyle>(UrlStyle_serializer::read(valueDeserializer));
+    const auto value_onOffsetChange = value.onOffsetChange;
+    Ark_Int32 value_onOffsetChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onOffsetChange_type = runtimeType(value_onOffsetChange);
+    valueSerializer.writeInt8(value_onOffsetChange_type);
+    if ((value_onOffsetChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onOffsetChange_value = value_onOffsetChange.value;
+        valueSerializer.writeCallbackResource(value_onOffsetChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onOffsetChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onOffsetChange_value.callSync));
     }
-    else if (styledValue_buf_selector == 10) {
-        styledValue_buf.selector = 10;
-        styledValue_buf.value10 = static_cast<Ark_CustomSpan>(CustomSpan_serializer::read(valueDeserializer));
+}
+inline Ark_SwipeActionOptions SwipeActionOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_SwipeActionOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_CustomBuilder_SwipeActionItem start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 start_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_CustomBuilder_SwipeActionItem start_buf_ = {};
+        start_buf_.selector = start_buf__selector;
+        if (start_buf__selector == 0) {
+            start_buf_.selector = 0;
+            start_buf_.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        }
+        else if (start_buf__selector == 1) {
+            start_buf_.selector = 1;
+            start_buf_.value1 = SwipeActionItem_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for start_buf_ has to be chosen through deserialisation.");
+        }
+        start_buf.value = static_cast<Ark_Union_CustomBuilder_SwipeActionItem>(start_buf_);
     }
-    else if (styledValue_buf_selector == 11) {
-        styledValue_buf.selector = 11;
-        styledValue_buf.value11 = static_cast<Ark_UserDataSpan>(UserDataSpan_serializer::read(valueDeserializer));
+    value.start = start_buf;
+    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_CustomBuilder_SwipeActionItem end_buf = {};
+    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 end_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_CustomBuilder_SwipeActionItem end_buf_ = {};
+        end_buf_.selector = end_buf__selector;
+        if (end_buf__selector == 0) {
+            end_buf_.selector = 0;
+            end_buf_.value0 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        }
+        else if (end_buf__selector == 1) {
+            end_buf_.selector = 1;
+            end_buf_.value1 = SwipeActionItem_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for end_buf_ has to be chosen through deserialisation.");
+        }
+        end_buf.value = static_cast<Ark_Union_CustomBuilder_SwipeActionItem>(end_buf_);
     }
-    else if (styledValue_buf_selector == 12) {
-        styledValue_buf.selector = 12;
-        styledValue_buf.value12 = static_cast<Ark_BackgroundColorStyle>(BackgroundColorStyle_serializer::read(valueDeserializer));
+    value.end = end_buf;
+    const auto edgeEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SwipeEdgeEffect edgeEffect_buf = {};
+    edgeEffect_buf.tag = edgeEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((edgeEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        edgeEffect_buf.value = static_cast<Ark_SwipeEdgeEffect>(valueDeserializer.readInt32());
     }
-    else {
-        INTEROP_FATAL("One of the branches for styledValue_buf has to be chosen through deserialisation.");
+    value.edgeEffect = edgeEffect_buf;
+    const auto onOffsetChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Number_Void onOffsetChange_buf = {};
+    onOffsetChange_buf.tag = onOffsetChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onOffsetChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onOffsetChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Number offset)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Number_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Number offset)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Number_Void))))};
     }
-    value.styledValue = static_cast<Ark_StyledStringValue>(styledValue_buf);
+    value.onOffsetChange = onOffsetChange_buf;
     return value;
 }
-inline void SubTabBarStyle_serializer::write(SerializerBase& buffer, Ark_SubTabBarStyle value)
+inline void SwipeGestureEvent_serializer::write(SerializerBase& buffer, Ark_SwipeGestureEvent value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value__content = value._content;
-    Ark_Int32 value__content_type = INTEROP_RUNTIME_UNDEFINED;
-    value__content_type = runtimeType(value__content);
-    valueSerializer.writeInt8(value__content_type);
-    if ((value__content_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__content_value = value__content.value;
-        Ark_Int32 value__content_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__content_value_type = value__content_value.selector;
-        if (value__content_value_type == 0) {
+    valueSerializer.writePointer(value);
+}
+inline Ark_SwipeGestureEvent SwipeGestureEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_SwipeGestureEvent>(ptr);
+}
+inline void TabBarLabelStyle_serializer::write(SerializerBase& buffer, Ark_TabBarLabelStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_overflow = value.overflow;
+    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_overflow_type = runtimeType(value_overflow);
+    valueSerializer.writeInt8(value_overflow_type);
+    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_overflow_value = value_overflow.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
+    }
+    const auto value_maxLines = value.maxLines;
+    Ark_Int32 value_maxLines_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maxLines_type = runtimeType(value_maxLines);
+    valueSerializer.writeInt8(value_maxLines_type);
+    if ((value_maxLines_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maxLines_value = value_maxLines.value;
+        valueSerializer.writeNumber(value_maxLines_value);
+    }
+    const auto value_minFontSize = value.minFontSize;
+    Ark_Int32 value_minFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_minFontSize_type = runtimeType(value_minFontSize);
+    valueSerializer.writeInt8(value_minFontSize_type);
+    if ((value_minFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_minFontSize_value = value_minFontSize.value;
+        Ark_Int32 value_minFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_minFontSize_value_type = value_minFontSize_value.selector;
+        if (value_minFontSize_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__content_value_0 = value__content_value.value0;
-            valueSerializer.writeString(value__content_value_0);
+            const auto value_minFontSize_value_0 = value_minFontSize_value.value0;
+            valueSerializer.writeNumber(value_minFontSize_value_0);
         }
-        else if (value__content_value_type == 1) {
+        else if ((value_minFontSize_value_type == 1) || (value_minFontSize_value_type == 1)) {
             valueSerializer.writeInt8(1);
-            const auto value__content_value_1 = value__content_value.value1;
-            Resource_serializer::write(valueSerializer, value__content_value_1);
-        }
-        else if (value__content_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value__content_value_2 = value__content_value.value2;
-            ComponentContent_serializer::write(valueSerializer, value__content_value_2);
+            const auto value_minFontSize_value_1 = value_minFontSize_value.value1;
+            Ark_Int32 value_minFontSize_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_minFontSize_value_1_type = value_minFontSize_value_1.selector;
+            if (value_minFontSize_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_minFontSize_value_1_0 = value_minFontSize_value_1.value0;
+                valueSerializer.writeString(value_minFontSize_value_1_0);
+            }
+            else if (value_minFontSize_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_minFontSize_value_1_1 = value_minFontSize_value_1.value1;
+                Resource_serializer::write(valueSerializer, value_minFontSize_value_1_1);
+            }
         }
     }
-    const auto value__indicator = value._indicator;
-    Ark_Int32 value__indicator_type = INTEROP_RUNTIME_UNDEFINED;
-    value__indicator_type = runtimeType(value__indicator);
-    valueSerializer.writeInt8(value__indicator_type);
-    if ((value__indicator_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__indicator_value = value__indicator.value;
-        SubTabBarIndicatorStyle_serializer::write(valueSerializer, value__indicator_value);
-    }
-    const auto value__selectedMode = value._selectedMode;
-    Ark_Int32 value__selectedMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value__selectedMode_type = runtimeType(value__selectedMode);
-    valueSerializer.writeInt8(value__selectedMode_type);
-    if ((value__selectedMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__selectedMode_value = value__selectedMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_SelectedMode>(value__selectedMode_value));
-    }
-    const auto value__board = value._board;
-    Ark_Int32 value__board_type = INTEROP_RUNTIME_UNDEFINED;
-    value__board_type = runtimeType(value__board);
-    valueSerializer.writeInt8(value__board_type);
-    if ((value__board_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__board_value = value__board.value;
-        BoardStyle_serializer::write(valueSerializer, value__board_value);
-    }
-    const auto value__labelStyle = value._labelStyle;
-    Ark_Int32 value__labelStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value__labelStyle_type = runtimeType(value__labelStyle);
-    valueSerializer.writeInt8(value__labelStyle_type);
-    if ((value__labelStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__labelStyle_value = value__labelStyle.value;
-        TabBarLabelStyle_serializer::write(valueSerializer, value__labelStyle_value);
-    }
-    const auto value__padding = value._padding;
-    Ark_Int32 value__padding_type = INTEROP_RUNTIME_UNDEFINED;
-    value__padding_type = runtimeType(value__padding);
-    valueSerializer.writeInt8(value__padding_type);
-    if ((value__padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__padding_value = value__padding.value;
-        Ark_Int32 value__padding_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value__padding_value_type = value__padding_value.selector;
-        if ((value__padding_value_type == 0) || (value__padding_value_type == 0) || (value__padding_value_type == 0) || (value__padding_value_type == 0)) {
+    const auto value_maxFontSize = value.maxFontSize;
+    Ark_Int32 value_maxFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maxFontSize_type = runtimeType(value_maxFontSize);
+    valueSerializer.writeInt8(value_maxFontSize_type);
+    if ((value_maxFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maxFontSize_value = value_maxFontSize.value;
+        Ark_Int32 value_maxFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_maxFontSize_value_type = value_maxFontSize_value.selector;
+        if (value_maxFontSize_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value__padding_value_0 = value__padding_value.value0;
-            Ark_Int32 value__padding_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value__padding_value_0_type = value__padding_value_0.selector;
-            if (value__padding_value_0_type == 0) {
+            const auto value_maxFontSize_value_0 = value_maxFontSize_value.value0;
+            valueSerializer.writeNumber(value_maxFontSize_value_0);
+        }
+        else if ((value_maxFontSize_value_type == 1) || (value_maxFontSize_value_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value_maxFontSize_value_1 = value_maxFontSize_value.value1;
+            Ark_Int32 value_maxFontSize_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value_maxFontSize_value_1_type = value_maxFontSize_value_1.selector;
+            if (value_maxFontSize_value_1_type == 0) {
                 valueSerializer.writeInt8(0);
-                const auto value__padding_value_0_0 = value__padding_value_0.value0;
-                Padding_serializer::write(valueSerializer, value__padding_value_0_0);
+                const auto value_maxFontSize_value_1_0 = value_maxFontSize_value_1.value0;
+                valueSerializer.writeString(value_maxFontSize_value_1_0);
             }
-            else if ((value__padding_value_0_type == 1) || (value__padding_value_0_type == 1) || (value__padding_value_0_type == 1)) {
+            else if (value_maxFontSize_value_1_type == 1) {
                 valueSerializer.writeInt8(1);
-                const auto value__padding_value_0_1 = value__padding_value_0.value1;
-                Ark_Int32 value__padding_value_0_1_type = INTEROP_RUNTIME_UNDEFINED;
-                value__padding_value_0_1_type = value__padding_value_0_1.selector;
-                if (value__padding_value_0_1_type == 0) {
-                    valueSerializer.writeInt8(0);
-                    const auto value__padding_value_0_1_0 = value__padding_value_0_1.value0;
-                    valueSerializer.writeString(value__padding_value_0_1_0);
-                }
-                else if (value__padding_value_0_1_type == 1) {
-                    valueSerializer.writeInt8(1);
-                    const auto value__padding_value_0_1_1 = value__padding_value_0_1.value1;
-                    valueSerializer.writeNumber(value__padding_value_0_1_1);
-                }
-                else if (value__padding_value_0_1_type == 2) {
-                    valueSerializer.writeInt8(2);
-                    const auto value__padding_value_0_1_2 = value__padding_value_0_1.value2;
-                    Resource_serializer::write(valueSerializer, value__padding_value_0_1_2);
-                }
+                const auto value_maxFontSize_value_1_1 = value_maxFontSize_value_1.value1;
+                Resource_serializer::write(valueSerializer, value_maxFontSize_value_1_1);
             }
         }
-        else if (value__padding_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value__padding_value_1 = value__padding_value.value1;
-            LocalizedPadding_serializer::write(valueSerializer, value__padding_value_1);
-        }
     }
-    const auto value__id = value._id;
-    Ark_Int32 value__id_type = INTEROP_RUNTIME_UNDEFINED;
-    value__id_type = runtimeType(value__id);
-    valueSerializer.writeInt8(value__id_type);
-    if ((value__id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value__id_value = value__id.value;
-        valueSerializer.writeString(value__id_value);
+    const auto value_heightAdaptivePolicy = value.heightAdaptivePolicy;
+    Ark_Int32 value_heightAdaptivePolicy_type = INTEROP_RUNTIME_UNDEFINED;
+    value_heightAdaptivePolicy_type = runtimeType(value_heightAdaptivePolicy);
+    valueSerializer.writeInt8(value_heightAdaptivePolicy_type);
+    if ((value_heightAdaptivePolicy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_heightAdaptivePolicy_value = value_heightAdaptivePolicy.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextHeightAdaptivePolicy>(value_heightAdaptivePolicy_value));
     }
-}
-inline Ark_SubTabBarStyle SubTabBarStyle_serializer::read(DeserializerBase& buffer)
-{
-    Ark_SubTabBarStyle value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto _content_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_String_Resource_ComponentContent _content_buf = {};
-    _content_buf.tag = _content_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_content_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 _content_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_String_Resource_ComponentContent _content_buf_ = {};
-        _content_buf_.selector = _content_buf__selector;
-        if (_content_buf__selector == 0) {
-            _content_buf_.selector = 0;
-            _content_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+    const auto value_font = value.font;
+    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
+    value_font_type = runtimeType(value_font);
+    valueSerializer.writeInt8(value_font_type);
+    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_font_value = value_font.value;
+        Font_serializer::write(valueSerializer, value_font_value);
+    }
+    const auto value_selectedColor = value.selectedColor;
+    Ark_Int32 value_selectedColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_selectedColor_type = runtimeType(value_selectedColor);
+    valueSerializer.writeInt8(value_selectedColor_type);
+    if ((value_selectedColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_selectedColor_value = value_selectedColor.value;
+        Ark_Int32 value_selectedColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_selectedColor_value_type = value_selectedColor_value.selector;
+        if (value_selectedColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_selectedColor_value_0 = value_selectedColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_selectedColor_value_0));
         }
-        else if (_content_buf__selector == 1) {
-            _content_buf_.selector = 1;
-            _content_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (value_selectedColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_selectedColor_value_1 = value_selectedColor_value.value1;
+            valueSerializer.writeNumber(value_selectedColor_value_1);
         }
-        else if (_content_buf__selector == 2) {
-            _content_buf_.selector = 2;
-            _content_buf_.value2 = static_cast<Ark_ComponentContent>(ComponentContent_serializer::read(valueDeserializer));
+        else if (value_selectedColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_selectedColor_value_2 = value_selectedColor_value.value2;
+            valueSerializer.writeString(value_selectedColor_value_2);
         }
-        else {
-            INTEROP_FATAL("One of the branches for _content_buf_ has to be chosen through deserialisation.");
+        else if (value_selectedColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_selectedColor_value_3 = value_selectedColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_selectedColor_value_3);
         }
-        _content_buf.value = static_cast<Ark_Union_String_Resource_ComponentContent>(_content_buf_);
     }
-    value._content = _content_buf;
-    const auto _indicator_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SubTabBarIndicatorStyle _indicator_buf = {};
-    _indicator_buf.tag = _indicator_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_indicator_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        _indicator_buf.value = SubTabBarIndicatorStyle_serializer::read(valueDeserializer);
+    const auto value_unselectedColor = value.unselectedColor;
+    Ark_Int32 value_unselectedColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_unselectedColor_type = runtimeType(value_unselectedColor);
+    valueSerializer.writeInt8(value_unselectedColor_type);
+    if ((value_unselectedColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_unselectedColor_value = value_unselectedColor.value;
+        Ark_Int32 value_unselectedColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_unselectedColor_value_type = value_unselectedColor_value.selector;
+        if (value_unselectedColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_unselectedColor_value_0 = value_unselectedColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_unselectedColor_value_0));
+        }
+        else if (value_unselectedColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_unselectedColor_value_1 = value_unselectedColor_value.value1;
+            valueSerializer.writeNumber(value_unselectedColor_value_1);
+        }
+        else if (value_unselectedColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_unselectedColor_value_2 = value_unselectedColor_value.value2;
+            valueSerializer.writeString(value_unselectedColor_value_2);
+        }
+        else if (value_unselectedColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_unselectedColor_value_3 = value_unselectedColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_unselectedColor_value_3);
+        }
     }
-    value._indicator = _indicator_buf;
-    const auto _selectedMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_SelectedMode _selectedMode_buf = {};
-    _selectedMode_buf.tag = _selectedMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_selectedMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+}
+inline Ark_TabBarLabelStyle TabBarLabelStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_TabBarLabelStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextOverflow overflow_buf = {};
+    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _selectedMode_buf.value = static_cast<Ark_SelectedMode>(valueDeserializer.readInt32());
+        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
     }
-    value._selectedMode = _selectedMode_buf;
-    const auto _board_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BoardStyle _board_buf = {};
-    _board_buf.tag = _board_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_board_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.overflow = overflow_buf;
+    const auto maxLines_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number maxLines_buf = {};
+    maxLines_buf.tag = maxLines_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maxLines_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _board_buf.value = BoardStyle_serializer::read(valueDeserializer);
+        maxLines_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value._board = _board_buf;
-    const auto _labelStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TabBarLabelStyle _labelStyle_buf = {};
-    _labelStyle_buf.tag = _labelStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_labelStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maxLines = maxLines_buf;
+    const auto minFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_ResourceStr minFontSize_buf = {};
+    minFontSize_buf.tag = minFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((minFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _labelStyle_buf.value = TabBarLabelStyle_serializer::read(valueDeserializer);
+        const Ark_Int8 minFontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_ResourceStr minFontSize_buf_ = {};
+        minFontSize_buf_.selector = minFontSize_buf__selector;
+        if (minFontSize_buf__selector == 0) {
+            minFontSize_buf_.selector = 0;
+            minFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (minFontSize_buf__selector == 1) {
+            minFontSize_buf_.selector = 1;
+            const Ark_Int8 minFontSize_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceStr minFontSize_buf__u = {};
+            minFontSize_buf__u.selector = minFontSize_buf__u_selector;
+            if (minFontSize_buf__u_selector == 0) {
+                minFontSize_buf__u.selector = 0;
+                minFontSize_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (minFontSize_buf__u_selector == 1) {
+                minFontSize_buf__u.selector = 1;
+                minFontSize_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for minFontSize_buf__u has to be chosen through deserialisation.");
+            }
+            minFontSize_buf_.value1 = static_cast<Ark_ResourceStr>(minFontSize_buf__u);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for minFontSize_buf_ has to be chosen through deserialisation.");
+        }
+        minFontSize_buf.value = static_cast<Ark_Union_Number_ResourceStr>(minFontSize_buf_);
     }
-    value._labelStyle = _labelStyle_buf;
-    const auto _padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Union_Padding_Dimension_LocalizedPadding _padding_buf = {};
-    _padding_buf.tag = _padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.minFontSize = minFontSize_buf;
+    const auto maxFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_ResourceStr maxFontSize_buf = {};
+    maxFontSize_buf.tag = maxFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maxFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 _padding_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Union_Padding_Dimension_LocalizedPadding _padding_buf_ = {};
-        _padding_buf_.selector = _padding_buf__selector;
-        if (_padding_buf__selector == 0) {
-            _padding_buf_.selector = 0;
-            const Ark_Int8 _padding_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Union_Padding_Dimension _padding_buf__u = {};
-            _padding_buf__u.selector = _padding_buf__u_selector;
-            if (_padding_buf__u_selector == 0) {
-                _padding_buf__u.selector = 0;
-                _padding_buf__u.value0 = Padding_serializer::read(valueDeserializer);
+        const Ark_Int8 maxFontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_ResourceStr maxFontSize_buf_ = {};
+        maxFontSize_buf_.selector = maxFontSize_buf__selector;
+        if (maxFontSize_buf__selector == 0) {
+            maxFontSize_buf_.selector = 0;
+            maxFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (maxFontSize_buf__selector == 1) {
+            maxFontSize_buf_.selector = 1;
+            const Ark_Int8 maxFontSize_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceStr maxFontSize_buf__u = {};
+            maxFontSize_buf__u.selector = maxFontSize_buf__u_selector;
+            if (maxFontSize_buf__u_selector == 0) {
+                maxFontSize_buf__u.selector = 0;
+                maxFontSize_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (_padding_buf__u_selector == 1) {
-                _padding_buf__u.selector = 1;
-                const Ark_Int8 _padding_buf__u_u_selector = valueDeserializer.readInt8();
-                Ark_Dimension _padding_buf__u_u = {};
-                _padding_buf__u_u.selector = _padding_buf__u_u_selector;
-                if (_padding_buf__u_u_selector == 0) {
-                    _padding_buf__u_u.selector = 0;
-                    _padding_buf__u_u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-                }
-                else if (_padding_buf__u_u_selector == 1) {
-                    _padding_buf__u_u.selector = 1;
-                    _padding_buf__u_u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-                }
-                else if (_padding_buf__u_u_selector == 2) {
-                    _padding_buf__u_u.selector = 2;
-                    _padding_buf__u_u.value2 = Resource_serializer::read(valueDeserializer);
-                }
-                else {
-                    INTEROP_FATAL("One of the branches for _padding_buf__u_u has to be chosen through deserialisation.");
-                }
-                _padding_buf__u.value1 = static_cast<Ark_Dimension>(_padding_buf__u_u);
+            else if (maxFontSize_buf__u_selector == 1) {
+                maxFontSize_buf__u.selector = 1;
+                maxFontSize_buf__u.value1 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for _padding_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for maxFontSize_buf__u has to be chosen through deserialisation.");
             }
-            _padding_buf_.value0 = static_cast<Ark_Union_Padding_Dimension>(_padding_buf__u);
-        }
-        else if (_padding_buf__selector == 1) {
-            _padding_buf_.selector = 1;
-            _padding_buf_.value1 = LocalizedPadding_serializer::read(valueDeserializer);
+            maxFontSize_buf_.value1 = static_cast<Ark_ResourceStr>(maxFontSize_buf__u);
         }
         else {
-            INTEROP_FATAL("One of the branches for _padding_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for maxFontSize_buf_ has to be chosen through deserialisation.");
         }
-        _padding_buf.value = static_cast<Ark_Union_Union_Padding_Dimension_LocalizedPadding>(_padding_buf_);
+        maxFontSize_buf.value = static_cast<Ark_Union_Number_ResourceStr>(maxFontSize_buf_);
     }
-    value._padding = _padding_buf;
-    const auto _id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String _id_buf = {};
-    _id_buf.tag = _id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((_id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maxFontSize = maxFontSize_buf;
+    const auto heightAdaptivePolicy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextHeightAdaptivePolicy heightAdaptivePolicy_buf = {};
+    heightAdaptivePolicy_buf.tag = heightAdaptivePolicy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((heightAdaptivePolicy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        _id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        heightAdaptivePolicy_buf.value = static_cast<Ark_TextHeightAdaptivePolicy>(valueDeserializer.readInt32());
     }
-    value._id = _id_buf;
-    return value;
-}
-inline void TextPickerDialogOptions_serializer::write(SerializerBase& buffer, Ark_TextPickerDialogOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_range = value.range;
-    Ark_Int32 value_range_type = INTEROP_RUNTIME_UNDEFINED;
-    value_range_type = value_range.selector;
-    if (value_range_type == 0) {
-        valueSerializer.writeInt8(0);
-        const auto value_range_0 = value_range.value0;
-        valueSerializer.writeInt32(value_range_0.length);
-        for (int value_range_0_counter_i = 0; value_range_0_counter_i < value_range_0.length; value_range_0_counter_i++) {
-            const Ark_String value_range_0_element = value_range_0.array[value_range_0_counter_i];
-            valueSerializer.writeString(value_range_0_element);
-        }
+    value.heightAdaptivePolicy = heightAdaptivePolicy_buf;
+    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font font_buf = {};
+    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        font_buf.value = Font_serializer::read(valueDeserializer);
     }
-    else if (value_range_type == 1) {
-        valueSerializer.writeInt8(1);
-        const auto value_range_1 = value_range.value1;
-        valueSerializer.writeInt32(value_range_1.length);
-        for (int value_range_1_counter_i = 0; value_range_1_counter_i < value_range_1.length; value_range_1_counter_i++) {
-            const Array_String value_range_1_element = value_range_1.array[value_range_1_counter_i];
-            valueSerializer.writeInt32(value_range_1_element.length);
-            for (int value_range_1_element_counter_i = 0; value_range_1_element_counter_i < value_range_1_element.length; value_range_1_element_counter_i++) {
-                const Ark_String value_range_1_element_element = value_range_1_element.array[value_range_1_element_counter_i];
-                valueSerializer.writeString(value_range_1_element_element);
-            }
+    value.font = font_buf;
+    const auto selectedColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor selectedColor_buf = {};
+    selectedColor_buf.tag = selectedColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((selectedColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 selectedColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor selectedColor_buf_ = {};
+        selectedColor_buf_.selector = selectedColor_buf__selector;
+        if (selectedColor_buf__selector == 0) {
+            selectedColor_buf_.selector = 0;
+            selectedColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-    }
-    else if (value_range_type == 2) {
-        valueSerializer.writeInt8(2);
-        const auto value_range_2 = value_range.value2;
-        Resource_serializer::write(valueSerializer, value_range_2);
-    }
-    else if (value_range_type == 3) {
-        valueSerializer.writeInt8(3);
-        const auto value_range_3 = value_range.value3;
-        valueSerializer.writeInt32(value_range_3.length);
-        for (int value_range_3_counter_i = 0; value_range_3_counter_i < value_range_3.length; value_range_3_counter_i++) {
-            const Ark_TextPickerRangeContent value_range_3_element = value_range_3.array[value_range_3_counter_i];
-            TextPickerRangeContent_serializer::write(valueSerializer, value_range_3_element);
+        else if (selectedColor_buf__selector == 1) {
+            selectedColor_buf_.selector = 1;
+            selectedColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-    }
-    else if (value_range_type == 4) {
-        valueSerializer.writeInt8(4);
-        const auto value_range_4 = value_range.value4;
-        valueSerializer.writeInt32(value_range_4.length);
-        for (int value_range_4_counter_i = 0; value_range_4_counter_i < value_range_4.length; value_range_4_counter_i++) {
-            const Ark_TextCascadePickerRangeContent value_range_4_element = value_range_4.array[value_range_4_counter_i];
-            TextCascadePickerRangeContent_serializer::write(valueSerializer, value_range_4_element);
+        else if (selectedColor_buf__selector == 2) {
+            selectedColor_buf_.selector = 2;
+            selectedColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-    }
-    const auto value_value = value.value;
-    Ark_Int32 value_value_type = INTEROP_RUNTIME_UNDEFINED;
-    value_value_type = runtimeType(value_value);
-    valueSerializer.writeInt8(value_value_type);
-    if ((value_value_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_value_value = value_value.value;
-        Ark_Int32 value_value_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_value_value_type = value_value_value.selector;
-        if ((value_value_value_type == 0) || (value_value_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_value_value_0 = value_value_value.value0;
-            Ark_Int32 value_value_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_value_value_0_type = value_value_value_0.selector;
-            if (value_value_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_value_value_0_0 = value_value_value_0.value0;
-                valueSerializer.writeString(value_value_value_0_0);
-            }
-            else if (value_value_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_value_value_0_1 = value_value_value_0.value1;
-                Resource_serializer::write(valueSerializer, value_value_value_0_1);
-            }
+        else if (selectedColor_buf__selector == 3) {
+            selectedColor_buf_.selector = 3;
+            selectedColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
-        else if (value_value_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_value_value_1 = value_value_value.value1;
-            valueSerializer.writeInt32(value_value_value_1.length);
-            for (int value_value_value_1_counter_i = 0; value_value_value_1_counter_i < value_value_value_1.length; value_value_value_1_counter_i++) {
-                const Ark_ResourceStr value_value_value_1_element = value_value_value_1.array[value_value_value_1_counter_i];
-                Ark_Int32 value_value_value_1_element_type = INTEROP_RUNTIME_UNDEFINED;
-                value_value_value_1_element_type = value_value_value_1_element.selector;
-                if (value_value_value_1_element_type == 0) {
-                    valueSerializer.writeInt8(0);
-                    const auto value_value_value_1_element_0 = value_value_value_1_element.value0;
-                    valueSerializer.writeString(value_value_value_1_element_0);
-                }
-                else if (value_value_value_1_element_type == 1) {
-                    valueSerializer.writeInt8(1);
-                    const auto value_value_value_1_element_1 = value_value_value_1_element.value1;
-                    Resource_serializer::write(valueSerializer, value_value_value_1_element_1);
-                }
-            }
+        else {
+            INTEROP_FATAL("One of the branches for selectedColor_buf_ has to be chosen through deserialisation.");
         }
+        selectedColor_buf.value = static_cast<Ark_ResourceColor>(selectedColor_buf_);
     }
-    const auto value_selected = value.selected;
-    Ark_Int32 value_selected_type = INTEROP_RUNTIME_UNDEFINED;
-    value_selected_type = runtimeType(value_selected);
-    valueSerializer.writeInt8(value_selected_type);
-    if ((value_selected_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_selected_value = value_selected.value;
-        Ark_Int32 value_selected_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_selected_value_type = value_selected_value.selector;
-        if (value_selected_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_selected_value_0 = value_selected_value.value0;
-            valueSerializer.writeNumber(value_selected_value_0);
+    value.selectedColor = selectedColor_buf;
+    const auto unselectedColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor unselectedColor_buf = {};
+    unselectedColor_buf.tag = unselectedColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((unselectedColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 unselectedColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor unselectedColor_buf_ = {};
+        unselectedColor_buf_.selector = unselectedColor_buf__selector;
+        if (unselectedColor_buf__selector == 0) {
+            unselectedColor_buf_.selector = 0;
+            unselectedColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (value_selected_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_selected_value_1 = value_selected_value.value1;
-            valueSerializer.writeInt32(value_selected_value_1.length);
-            for (int value_selected_value_1_counter_i = 0; value_selected_value_1_counter_i < value_selected_value_1.length; value_selected_value_1_counter_i++) {
-                const Ark_Number value_selected_value_1_element = value_selected_value_1.array[value_selected_value_1_counter_i];
-                valueSerializer.writeNumber(value_selected_value_1_element);
-            }
+        else if (unselectedColor_buf__selector == 1) {
+            unselectedColor_buf_.selector = 1;
+            unselectedColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-    }
-    const auto value_columnWidths = value.columnWidths;
-    Ark_Int32 value_columnWidths_type = INTEROP_RUNTIME_UNDEFINED;
-    value_columnWidths_type = runtimeType(value_columnWidths);
-    valueSerializer.writeInt8(value_columnWidths_type);
-    if ((value_columnWidths_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_columnWidths_value = value_columnWidths.value;
-        valueSerializer.writeInt32(value_columnWidths_value.length);
-        for (int value_columnWidths_value_counter_i = 0; value_columnWidths_value_counter_i < value_columnWidths_value.length; value_columnWidths_value_counter_i++) {
-            const Ark_LengthMetrics value_columnWidths_value_element = value_columnWidths_value.array[value_columnWidths_value_counter_i];
-            LengthMetrics_serializer::write(valueSerializer, value_columnWidths_value_element);
+        else if (unselectedColor_buf__selector == 2) {
+            unselectedColor_buf_.selector = 2;
+            unselectedColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-    }
-    const auto value_defaultPickerItemHeight = value.defaultPickerItemHeight;
-    Ark_Int32 value_defaultPickerItemHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_defaultPickerItemHeight_type = runtimeType(value_defaultPickerItemHeight);
-    valueSerializer.writeInt8(value_defaultPickerItemHeight_type);
-    if ((value_defaultPickerItemHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_defaultPickerItemHeight_value = value_defaultPickerItemHeight.value;
-        Ark_Int32 value_defaultPickerItemHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_defaultPickerItemHeight_value_type = value_defaultPickerItemHeight_value.selector;
-        if (value_defaultPickerItemHeight_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_defaultPickerItemHeight_value_0 = value_defaultPickerItemHeight_value.value0;
-            valueSerializer.writeNumber(value_defaultPickerItemHeight_value_0);
+        else if (unselectedColor_buf__selector == 3) {
+            unselectedColor_buf_.selector = 3;
+            unselectedColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
-        else if (value_defaultPickerItemHeight_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_defaultPickerItemHeight_value_1 = value_defaultPickerItemHeight_value.value1;
-            valueSerializer.writeString(value_defaultPickerItemHeight_value_1);
+        else {
+            INTEROP_FATAL("One of the branches for unselectedColor_buf_ has to be chosen through deserialisation.");
         }
+        unselectedColor_buf.value = static_cast<Ark_ResourceColor>(unselectedColor_buf_);
     }
-    const auto value_canLoop = value.canLoop;
-    Ark_Int32 value_canLoop_type = INTEROP_RUNTIME_UNDEFINED;
-    value_canLoop_type = runtimeType(value_canLoop);
-    valueSerializer.writeInt8(value_canLoop_type);
-    if ((value_canLoop_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_canLoop_value = value_canLoop.value;
-        valueSerializer.writeBoolean(value_canLoop_value);
-    }
-    const auto value_disappearTextStyle = value.disappearTextStyle;
-    Ark_Int32 value_disappearTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_disappearTextStyle_type = runtimeType(value_disappearTextStyle);
-    valueSerializer.writeInt8(value_disappearTextStyle_type);
-    if ((value_disappearTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_disappearTextStyle_value = value_disappearTextStyle.value;
-        PickerTextStyle_serializer::write(valueSerializer, value_disappearTextStyle_value);
-    }
+    value.unselectedColor = unselectedColor_buf;
+    return value;
+}
+inline void TapGestureEvent_serializer::write(SerializerBase& buffer, Ark_TapGestureEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_TapGestureEvent TapGestureEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_TapGestureEvent>(ptr);
+}
+inline void text_ParagraphStyle_serializer::write(SerializerBase& buffer, Ark_text_ParagraphStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
     const auto value_textStyle = value.textStyle;
     Ark_Int32 value_textStyle_type = INTEROP_RUNTIME_UNDEFINED;
     value_textStyle_type = runtimeType(value_textStyle);
     valueSerializer.writeInt8(value_textStyle_type);
     if ((value_textStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
         const auto value_textStyle_value = value_textStyle.value;
-        PickerTextStyle_serializer::write(valueSerializer, value_textStyle_value);
+        text_TextStyle_serializer::write(valueSerializer, value_textStyle_value);
     }
-    const auto value_acceptButtonStyle = value.acceptButtonStyle;
-    Ark_Int32 value_acceptButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_acceptButtonStyle_type = runtimeType(value_acceptButtonStyle);
-    valueSerializer.writeInt8(value_acceptButtonStyle_type);
-    if ((value_acceptButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_acceptButtonStyle_value = value_acceptButtonStyle.value;
-        PickerDialogButtonStyle_serializer::write(valueSerializer, value_acceptButtonStyle_value);
+    const auto value_textDirection = value.textDirection;
+    Ark_Int32 value_textDirection_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textDirection_type = runtimeType(value_textDirection);
+    valueSerializer.writeInt8(value_textDirection_type);
+    if ((value_textDirection_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textDirection_value = value_textDirection.value;
+        valueSerializer.writeInt32(static_cast<Ark_text_TextDirection>(value_textDirection_value));
     }
-    const auto value_cancelButtonStyle = value.cancelButtonStyle;
-    Ark_Int32 value_cancelButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_cancelButtonStyle_type = runtimeType(value_cancelButtonStyle);
-    valueSerializer.writeInt8(value_cancelButtonStyle_type);
-    if ((value_cancelButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_cancelButtonStyle_value = value_cancelButtonStyle.value;
-        PickerDialogButtonStyle_serializer::write(valueSerializer, value_cancelButtonStyle_value);
+    const auto value_align = value.align;
+    Ark_Int32 value_align_type = INTEROP_RUNTIME_UNDEFINED;
+    value_align_type = runtimeType(value_align);
+    valueSerializer.writeInt8(value_align_type);
+    if ((value_align_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_align_value = value_align.value;
+        valueSerializer.writeInt32(static_cast<Ark_text_TextAlign>(value_align_value));
     }
-    const auto value_selectedTextStyle = value.selectedTextStyle;
-    Ark_Int32 value_selectedTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_selectedTextStyle_type = runtimeType(value_selectedTextStyle);
-    valueSerializer.writeInt8(value_selectedTextStyle_type);
-    if ((value_selectedTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_selectedTextStyle_value = value_selectedTextStyle.value;
-        PickerTextStyle_serializer::write(valueSerializer, value_selectedTextStyle_value);
+    const auto value_wordBreak = value.wordBreak;
+    Ark_Int32 value_wordBreak_type = INTEROP_RUNTIME_UNDEFINED;
+    value_wordBreak_type = runtimeType(value_wordBreak);
+    valueSerializer.writeInt8(value_wordBreak_type);
+    if ((value_wordBreak_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_wordBreak_value = value_wordBreak.value;
+        valueSerializer.writeInt32(static_cast<Ark_text_WordBreak>(value_wordBreak_value));
     }
-    const auto value_disableTextStyleAnimation = value.disableTextStyleAnimation;
-    Ark_Int32 value_disableTextStyleAnimation_type = INTEROP_RUNTIME_UNDEFINED;
-    value_disableTextStyleAnimation_type = runtimeType(value_disableTextStyleAnimation);
-    valueSerializer.writeInt8(value_disableTextStyleAnimation_type);
-    if ((value_disableTextStyleAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_disableTextStyleAnimation_value = value_disableTextStyleAnimation.value;
-        valueSerializer.writeBoolean(value_disableTextStyleAnimation_value);
+    const auto value_maxLines = value.maxLines;
+    Ark_Int32 value_maxLines_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maxLines_type = runtimeType(value_maxLines);
+    valueSerializer.writeInt8(value_maxLines_type);
+    if ((value_maxLines_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maxLines_value = value_maxLines.value;
+        valueSerializer.writeNumber(value_maxLines_value);
     }
-    const auto value_defaultTextStyle = value.defaultTextStyle;
-    Ark_Int32 value_defaultTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_defaultTextStyle_type = runtimeType(value_defaultTextStyle);
-    valueSerializer.writeInt8(value_defaultTextStyle_type);
-    if ((value_defaultTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_defaultTextStyle_value = value_defaultTextStyle.value;
-        TextPickerTextStyle_serializer::write(valueSerializer, value_defaultTextStyle_value);
+    const auto value_breakStrategy = value.breakStrategy;
+    Ark_Int32 value_breakStrategy_type = INTEROP_RUNTIME_UNDEFINED;
+    value_breakStrategy_type = runtimeType(value_breakStrategy);
+    valueSerializer.writeInt8(value_breakStrategy_type);
+    if ((value_breakStrategy_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_breakStrategy_value = value_breakStrategy.value;
+        valueSerializer.writeInt32(static_cast<Ark_text_BreakStrategy>(value_breakStrategy_value));
     }
-    const auto value_onAccept = value.onAccept;
-    Ark_Int32 value_onAccept_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onAccept_type = runtimeType(value_onAccept);
-    valueSerializer.writeInt8(value_onAccept_type);
-    if ((value_onAccept_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onAccept_value = value_onAccept.value;
-        valueSerializer.writeCallbackResource(value_onAccept_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.callSync));
+    const auto value_strutStyle = value.strutStyle;
+    Ark_Int32 value_strutStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_strutStyle_type = runtimeType(value_strutStyle);
+    valueSerializer.writeInt8(value_strutStyle_type);
+    if ((value_strutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_strutStyle_value = value_strutStyle.value;
+        text_StrutStyle_serializer::write(valueSerializer, value_strutStyle_value);
     }
-    const auto value_onCancel = value.onCancel;
-    Ark_Int32 value_onCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onCancel_type = runtimeType(value_onCancel);
-    valueSerializer.writeInt8(value_onCancel_type);
-    if ((value_onCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onCancel_value = value_onCancel.value;
-        valueSerializer.writeCallbackResource(value_onCancel_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.callSync));
+    const auto value_textHeightBehavior = value.textHeightBehavior;
+    Ark_Int32 value_textHeightBehavior_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textHeightBehavior_type = runtimeType(value_textHeightBehavior);
+    valueSerializer.writeInt8(value_textHeightBehavior_type);
+    if ((value_textHeightBehavior_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textHeightBehavior_value = value_textHeightBehavior.value;
+        valueSerializer.writeInt32(static_cast<Ark_text_TextHeightBehavior>(value_textHeightBehavior_value));
     }
-    const auto value_onChange = value.onChange;
-    Ark_Int32 value_onChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onChange_type = runtimeType(value_onChange);
-    valueSerializer.writeInt8(value_onChange_type);
-    if ((value_onChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onChange_value = value_onChange.value;
-        valueSerializer.writeCallbackResource(value_onChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.callSync));
+    const auto value_tab = value.tab;
+    Ark_Int32 value_tab_type = INTEROP_RUNTIME_UNDEFINED;
+    value_tab_type = runtimeType(value_tab);
+    valueSerializer.writeInt8(value_tab_type);
+    if ((value_tab_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_tab_value = value_tab.value;
+        text_TextTab_serializer::write(valueSerializer, value_tab_value);
     }
-    const auto value_onScrollStop = value.onScrollStop;
-    Ark_Int32 value_onScrollStop_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onScrollStop_type = runtimeType(value_onScrollStop);
-    valueSerializer.writeInt8(value_onScrollStop_type);
-    if ((value_onScrollStop_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onScrollStop_value = value_onScrollStop.value;
-        valueSerializer.writeCallbackResource(value_onScrollStop_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onScrollStop_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onScrollStop_value.callSync));
+}
+inline Ark_text_ParagraphStyle text_ParagraphStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_text_ParagraphStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto textStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_TextStyle textStyle_buf = {};
+    textStyle_buf.tag = textStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        textStyle_buf.value = text_TextStyle_serializer::read(valueDeserializer);
     }
-    const auto value_onEnterSelectedArea = value.onEnterSelectedArea;
-    Ark_Int32 value_onEnterSelectedArea_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onEnterSelectedArea_type = runtimeType(value_onEnterSelectedArea);
-    valueSerializer.writeInt8(value_onEnterSelectedArea_type);
-    if ((value_onEnterSelectedArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onEnterSelectedArea_value = value_onEnterSelectedArea.value;
-        valueSerializer.writeCallbackResource(value_onEnterSelectedArea_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onEnterSelectedArea_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onEnterSelectedArea_value.callSync));
+    value.textStyle = textStyle_buf;
+    const auto textDirection_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_TextDirection textDirection_buf = {};
+    textDirection_buf.tag = textDirection_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textDirection_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        textDirection_buf.value = static_cast<Ark_text_TextDirection>(valueDeserializer.readInt32());
     }
-    const auto value_maskRect = value.maskRect;
-    Ark_Int32 value_maskRect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_maskRect_type = runtimeType(value_maskRect);
-    valueSerializer.writeInt8(value_maskRect_type);
-    if ((value_maskRect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_maskRect_value = value_maskRect.value;
-        Rectangle_serializer::write(valueSerializer, value_maskRect_value);
+    value.textDirection = textDirection_buf;
+    const auto align_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_TextAlign align_buf = {};
+    align_buf.tag = align_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((align_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        align_buf.value = static_cast<Ark_text_TextAlign>(valueDeserializer.readInt32());
     }
-    const auto value_alignment = value.alignment;
-    Ark_Int32 value_alignment_type = INTEROP_RUNTIME_UNDEFINED;
-    value_alignment_type = runtimeType(value_alignment);
-    valueSerializer.writeInt8(value_alignment_type);
-    if ((value_alignment_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_alignment_value = value_alignment.value;
-        valueSerializer.writeInt32(static_cast<Ark_DialogAlignment>(value_alignment_value));
+    value.align = align_buf;
+    const auto wordBreak_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_WordBreak wordBreak_buf = {};
+    wordBreak_buf.tag = wordBreak_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((wordBreak_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        wordBreak_buf.value = static_cast<Ark_text_WordBreak>(valueDeserializer.readInt32());
     }
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Offset_serializer::write(valueSerializer, value_offset_value);
+    value.wordBreak = wordBreak_buf;
+    const auto maxLines_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number maxLines_buf = {};
+    maxLines_buf.tag = maxLines_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maxLines_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        maxLines_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    value.maxLines = maxLines_buf;
+    const auto breakStrategy_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_BreakStrategy breakStrategy_buf = {};
+    breakStrategy_buf.tag = breakStrategy_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((breakStrategy_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        breakStrategy_buf.value = static_cast<Ark_text_BreakStrategy>(valueDeserializer.readInt32());
+    }
+    value.breakStrategy = breakStrategy_buf;
+    const auto strutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_StrutStyle strutStyle_buf = {};
+    strutStyle_buf.tag = strutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((strutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        strutStyle_buf.value = text_StrutStyle_serializer::read(valueDeserializer);
+    }
+    value.strutStyle = strutStyle_buf;
+    const auto textHeightBehavior_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_TextHeightBehavior textHeightBehavior_buf = {};
+    textHeightBehavior_buf.tag = textHeightBehavior_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textHeightBehavior_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        textHeightBehavior_buf.value = static_cast<Ark_text_TextHeightBehavior>(valueDeserializer.readInt32());
+    }
+    value.textHeightBehavior = textHeightBehavior_buf;
+    const auto tab_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_text_TextTab tab_buf = {};
+    tab_buf.tag = tab_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((tab_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        tab_buf.value = text_TextTab_serializer::read(valueDeserializer);
+    }
+    value.tab = tab_buf;
+    return value;
+}
+inline void text_RunMetrics_serializer::write(SerializerBase& buffer, Ark_text_RunMetrics value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_textStyle = value.textStyle;
+    text_TextStyle_serializer::write(valueSerializer, value_textStyle);
+    const auto value_fontMetrics = value.fontMetrics;
+    drawing_FontMetrics_serializer::write(valueSerializer, value_fontMetrics);
+}
+inline Ark_text_RunMetrics text_RunMetrics_serializer::read(DeserializerBase& buffer)
+{
+    Ark_text_RunMetrics value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.textStyle = text_TextStyle_serializer::read(valueDeserializer);
+    value.fontMetrics = drawing_FontMetrics_serializer::read(valueDeserializer);
+    return value;
+}
+inline void TextBackgroundStyle_serializer::write(SerializerBase& buffer, Ark_TextBackgroundStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_color = value.color;
+    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
+    value_color_type = runtimeType(value_color);
+    valueSerializer.writeInt8(value_color_type);
+    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_color_value = value_color.value;
+        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_color_value_type = value_color_value.selector;
+        if (value_color_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_color_value_0 = value_color_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0));
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_color_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
+            const auto value_color_value_1 = value_color_value.value1;
+            valueSerializer.writeNumber(value_color_value_1);
         }
-        else if (value_backgroundColor_value_type == 2) {
+        else if (value_color_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
+            const auto value_color_value_2 = value_color_value.value2;
+            valueSerializer.writeString(value_color_value_2);
         }
-        else if (value_backgroundColor_value_type == 3) {
+        else if (value_color_value_type == 3) {
             valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_color_value_3 = value_color_value.value3;
+            Resource_serializer::write(valueSerializer, value_color_value_3);
         }
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
-    }
-    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
-    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
-    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
-    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
-        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
-    }
-    const auto value_backgroundEffect = value.backgroundEffect;
-    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
-    valueSerializer.writeInt8(value_backgroundEffect_type);
-    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundEffect_value = value_backgroundEffect.value;
-        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
-    }
-    const auto value_onDidAppear = value.onDidAppear;
-    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidAppear_type = runtimeType(value_onDidAppear);
-    valueSerializer.writeInt8(value_onDidAppear_type);
-    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidAppear_value = value_onDidAppear.value;
-        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
-    }
-    const auto value_onDidDisappear = value.onDidDisappear;
-    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
-    valueSerializer.writeInt8(value_onDidDisappear_type);
-    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDidDisappear_value = value_onDidDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
-    }
-    const auto value_onWillAppear = value.onWillAppear;
-    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillAppear_type = runtimeType(value_onWillAppear);
-    valueSerializer.writeInt8(value_onWillAppear_type);
-    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillAppear_value = value_onWillAppear.value;
-        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
-    }
-    const auto value_onWillDisappear = value.onWillDisappear;
-    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
-    valueSerializer.writeInt8(value_onWillDisappear_type);
-    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDisappear_value = value_onWillDisappear.value;
-        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
-    }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
+    const auto value_radius = value.radius;
+    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_radius_type = runtimeType(value_radius);
+    valueSerializer.writeInt8(value_radius_type);
+    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_radius_value = value_radius.value;
+        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_radius_value_type = value_radius_value.selector;
+        if ((value_radius_value_type == 0) || (value_radius_value_type == 0) || (value_radius_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+            const auto value_radius_value_0 = value_radius_value.value0;
+            Ark_Int32 value_radius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_radius_value_0_type = value_radius_value_0.selector;
+            if (value_radius_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_radius_value_0_0 = value_radius_value_0.value0;
+                valueSerializer.writeString(value_radius_value_0_0);
+            }
+            else if (value_radius_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_radius_value_0_1 = value_radius_value_0.value1;
+                valueSerializer.writeNumber(value_radius_value_0_1);
+            }
+            else if (value_radius_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_radius_value_0_2 = value_radius_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_radius_value_0_2);
+            }
         }
-        else if (value_shadow_value_type == 1) {
+        else if (value_radius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+            const auto value_radius_value_1 = value_radius_value.value1;
+            BorderRadiuses_serializer::write(valueSerializer, value_radius_value_1);
         }
     }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHoverMode_value = value_enableHoverMode.value;
-        valueSerializer.writeBoolean(value_enableHoverMode_value);
-    }
-    const auto value_hoverModeArea = value.hoverModeArea;
-    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
-    valueSerializer.writeInt8(value_hoverModeArea_type);
-    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hoverModeArea_value = value_hoverModeArea.value;
-        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
-    }
-    const auto value_enableHapticFeedback = value.enableHapticFeedback;
-    Ark_Int32 value_enableHapticFeedback_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHapticFeedback_type = runtimeType(value_enableHapticFeedback);
-    valueSerializer.writeInt8(value_enableHapticFeedback_type);
-    if ((value_enableHapticFeedback_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHapticFeedback_value = value_enableHapticFeedback.value;
-        valueSerializer.writeBoolean(value_enableHapticFeedback_value);
-    }
 }
-inline Ark_TextPickerDialogOptions TextPickerDialogOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_TextBackgroundStyle TextBackgroundStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_TextPickerDialogOptions value = {};
+    Ark_TextBackgroundStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const Ark_Int8 range_buf_selector = valueDeserializer.readInt8();
-    Ark_Union_Array_String_Array_Array_String_Resource_Array_TextPickerRangeContent_Array_TextCascadePickerRangeContent range_buf = {};
-    range_buf.selector = range_buf_selector;
-    if (range_buf_selector == 0) {
-        range_buf.selector = 0;
-        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
-        Array_String range_buf_u = {};
-        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
-        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
-        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
-            range_buf_u.array[range_buf_u_i] = static_cast<Ark_String>(valueDeserializer.readString());
+    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor color_buf = {};
+    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor color_buf_ = {};
+        color_buf_.selector = color_buf__selector;
+        if (color_buf__selector == 0) {
+            color_buf_.selector = 0;
+            color_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        range_buf.value0 = range_buf_u;
-    }
-    else if (range_buf_selector == 1) {
-        range_buf.selector = 1;
-        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
-        Array_Array_String range_buf_u = {};
-        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
-        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
-        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
-            const Ark_Int32 range_buf_u_buf_length = valueDeserializer.readInt32();
-            Array_String range_buf_u_buf = {};
-            valueDeserializer.resizeArray<std::decay<decltype(range_buf_u_buf)>::type,
-        std::decay<decltype(*range_buf_u_buf.array)>::type>(&range_buf_u_buf, range_buf_u_buf_length);
-            for (int range_buf_u_buf_i = 0; range_buf_u_buf_i < range_buf_u_buf_length; range_buf_u_buf_i++) {
-                range_buf_u_buf.array[range_buf_u_buf_i] = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            range_buf_u.array[range_buf_u_i] = range_buf_u_buf;
+        else if (color_buf__selector == 1) {
+            color_buf_.selector = 1;
+            color_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        range_buf.value1 = range_buf_u;
-    }
-    else if (range_buf_selector == 2) {
-        range_buf.selector = 2;
-        range_buf.value2 = Resource_serializer::read(valueDeserializer);
-    }
-    else if (range_buf_selector == 3) {
-        range_buf.selector = 3;
-        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
-        Array_TextPickerRangeContent range_buf_u = {};
-        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
-        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
-        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
-            range_buf_u.array[range_buf_u_i] = TextPickerRangeContent_serializer::read(valueDeserializer);
+        else if (color_buf__selector == 2) {
+            color_buf_.selector = 2;
+            color_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        range_buf.value3 = range_buf_u;
-    }
-    else if (range_buf_selector == 4) {
-        range_buf.selector = 4;
-        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
-        Array_TextCascadePickerRangeContent range_buf_u = {};
-        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
-        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
-        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
-            range_buf_u.array[range_buf_u_i] = TextCascadePickerRangeContent_serializer::read(valueDeserializer);
+        else if (color_buf__selector == 3) {
+            color_buf_.selector = 3;
+            color_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
-        range_buf.value4 = range_buf_u;
-    }
-    else {
-        INTEROP_FATAL("One of the branches for range_buf has to be chosen through deserialisation.");
+        else {
+            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
+        }
+        color_buf.value = static_cast<Ark_ResourceColor>(color_buf_);
     }
-    value.range = static_cast<Ark_Union_Array_String_Array_Array_String_Resource_Array_TextPickerRangeContent_Array_TextCascadePickerRangeContent>(range_buf);
-    const auto value_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceStr_Array_ResourceStr value_buf = {};
-    value_buf.tag = value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.color = color_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Dimension_BorderRadiuses radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 value_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceStr_Array_ResourceStr value_buf_ = {};
-        value_buf_.selector = value_buf__selector;
-        if (value_buf__selector == 0) {
-            value_buf_.selector = 0;
-            const Ark_Int8 value_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceStr value_buf__u = {};
-            value_buf__u.selector = value_buf__u_selector;
-            if (value_buf__u_selector == 0) {
-                value_buf__u.selector = 0;
-                value_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Dimension_BorderRadiuses radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            const Ark_Int8 radius_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension radius_buf__u = {};
+            radius_buf__u.selector = radius_buf__u_selector;
+            if (radius_buf__u_selector == 0) {
+                radius_buf__u.selector = 0;
+                radius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
             }
-            else if (value_buf__u_selector == 1) {
-                value_buf__u.selector = 1;
-                value_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            else if (radius_buf__u_selector == 1) {
+                radius_buf__u.selector = 1;
+                radius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (radius_buf__u_selector == 2) {
+                radius_buf__u.selector = 2;
+                radius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
             }
             else {
-                INTEROP_FATAL("One of the branches for value_buf__u has to be chosen through deserialisation.");
+                INTEROP_FATAL("One of the branches for radius_buf__u has to be chosen through deserialisation.");
             }
-            value_buf_.value0 = static_cast<Ark_ResourceStr>(value_buf__u);
+            radius_buf_.value0 = static_cast<Ark_Dimension>(radius_buf__u);
         }
-        else if (value_buf__selector == 1) {
-            value_buf_.selector = 1;
-            const Ark_Int32 value_buf__u_length = valueDeserializer.readInt32();
-            Array_ResourceStr value_buf__u = {};
-            valueDeserializer.resizeArray<std::decay<decltype(value_buf__u)>::type,
-        std::decay<decltype(*value_buf__u.array)>::type>(&value_buf__u, value_buf__u_length);
-            for (int value_buf__u_i = 0; value_buf__u_i < value_buf__u_length; value_buf__u_i++) {
-                const Ark_Int8 value_buf__u_buf_selector = valueDeserializer.readInt8();
-                Ark_ResourceStr value_buf__u_buf = {};
-                value_buf__u_buf.selector = value_buf__u_buf_selector;
-                if (value_buf__u_buf_selector == 0) {
-                    value_buf__u_buf.selector = 0;
-                    value_buf__u_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-                }
-                else if (value_buf__u_buf_selector == 1) {
-                    value_buf__u_buf.selector = 1;
-                    value_buf__u_buf.value1 = Resource_serializer::read(valueDeserializer);
-                }
-                else {
-                    INTEROP_FATAL("One of the branches for value_buf__u_buf has to be chosen through deserialisation.");
-                }
-                value_buf__u.array[value_buf__u_i] = static_cast<Ark_ResourceStr>(value_buf__u_buf);
-            }
-            value_buf_.value1 = value_buf__u;
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            radius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for value_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
         }
-        value_buf.value = static_cast<Ark_Union_ResourceStr_Array_ResourceStr>(value_buf_);
+        radius_buf.value = static_cast<Ark_Union_Dimension_BorderRadiuses>(radius_buf_);
     }
-    value.value = value_buf;
-    const auto selected_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_Array_Number selected_buf = {};
-    selected_buf.tag = selected_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((selected_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 selected_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_Array_Number selected_buf_ = {};
-        selected_buf_.selector = selected_buf__selector;
-        if (selected_buf__selector == 0) {
-            selected_buf_.selector = 0;
-            selected_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.radius = radius_buf;
+    return value;
+}
+inline void TextPickerTextStyle_serializer::write(SerializerBase& buffer, Ark_TextPickerTextStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_color = value.color;
+    Ark_Int32 value_color_type = INTEROP_RUNTIME_UNDEFINED;
+    value_color_type = runtimeType(value_color);
+    valueSerializer.writeInt8(value_color_type);
+    if ((value_color_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_color_value = value_color.value;
+        Ark_Int32 value_color_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_color_value_type = value_color_value.selector;
+        if (value_color_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_color_value_0 = value_color_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_color_value_0));
         }
-        else if (selected_buf__selector == 1) {
-            selected_buf_.selector = 1;
-            const Ark_Int32 selected_buf__u_length = valueDeserializer.readInt32();
-            Array_Number selected_buf__u = {};
-            valueDeserializer.resizeArray<std::decay<decltype(selected_buf__u)>::type,
-        std::decay<decltype(*selected_buf__u.array)>::type>(&selected_buf__u, selected_buf__u_length);
-            for (int selected_buf__u_i = 0; selected_buf__u_i < selected_buf__u_length; selected_buf__u_i++) {
-                selected_buf__u.array[selected_buf__u_i] = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            selected_buf_.value1 = selected_buf__u;
+        else if (value_color_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_color_value_1 = value_color_value.value1;
+            valueSerializer.writeNumber(value_color_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for selected_buf_ has to be chosen through deserialisation.");
+        else if (value_color_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_color_value_2 = value_color_value.value2;
+            valueSerializer.writeString(value_color_value_2);
         }
-        selected_buf.value = static_cast<Ark_Union_Number_Array_Number>(selected_buf_);
-    }
-    value.selected = selected_buf;
-    const auto columnWidths_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Array_LengthMetrics columnWidths_buf = {};
-    columnWidths_buf.tag = columnWidths_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((columnWidths_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int32 columnWidths_buf__length = valueDeserializer.readInt32();
-        Array_LengthMetrics columnWidths_buf_ = {};
-        valueDeserializer.resizeArray<std::decay<decltype(columnWidths_buf_)>::type,
-        std::decay<decltype(*columnWidths_buf_.array)>::type>(&columnWidths_buf_, columnWidths_buf__length);
-        for (int columnWidths_buf__i = 0; columnWidths_buf__i < columnWidths_buf__length; columnWidths_buf__i++) {
-            columnWidths_buf_.array[columnWidths_buf__i] = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
+        else if (value_color_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_color_value_3 = value_color_value.value3;
+            Resource_serializer::write(valueSerializer, value_color_value_3);
         }
-        columnWidths_buf.value = columnWidths_buf_;
     }
-    value.columnWidths = columnWidths_buf;
-    const auto defaultPickerItemHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Number_String defaultPickerItemHeight_buf = {};
-    defaultPickerItemHeight_buf.tag = defaultPickerItemHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((defaultPickerItemHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 defaultPickerItemHeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Number_String defaultPickerItemHeight_buf_ = {};
-        defaultPickerItemHeight_buf_.selector = defaultPickerItemHeight_buf__selector;
-        if (defaultPickerItemHeight_buf__selector == 0) {
-            defaultPickerItemHeight_buf_.selector = 0;
-            defaultPickerItemHeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto value_font = value.font;
+    Ark_Int32 value_font_type = INTEROP_RUNTIME_UNDEFINED;
+    value_font_type = runtimeType(value_font);
+    valueSerializer.writeInt8(value_font_type);
+    if ((value_font_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_font_value = value_font.value;
+        Font_serializer::write(valueSerializer, value_font_value);
+    }
+    const auto value_minFontSize = value.minFontSize;
+    Ark_Int32 value_minFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_minFontSize_type = runtimeType(value_minFontSize);
+    valueSerializer.writeInt8(value_minFontSize_type);
+    if ((value_minFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_minFontSize_value = value_minFontSize.value;
+        Ark_Int32 value_minFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_minFontSize_value_type = value_minFontSize_value.selector;
+        if (value_minFontSize_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_minFontSize_value_0 = value_minFontSize_value.value0;
+            valueSerializer.writeNumber(value_minFontSize_value_0);
         }
-        else if (defaultPickerItemHeight_buf__selector == 1) {
-            defaultPickerItemHeight_buf_.selector = 1;
-            defaultPickerItemHeight_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (value_minFontSize_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_minFontSize_value_1 = value_minFontSize_value.value1;
+            valueSerializer.writeString(value_minFontSize_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for defaultPickerItemHeight_buf_ has to be chosen through deserialisation.");
+        else if (value_minFontSize_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_minFontSize_value_2 = value_minFontSize_value.value2;
+            Resource_serializer::write(valueSerializer, value_minFontSize_value_2);
         }
-        defaultPickerItemHeight_buf.value = static_cast<Ark_Union_Number_String>(defaultPickerItemHeight_buf_);
-    }
-    value.defaultPickerItemHeight = defaultPickerItemHeight_buf;
-    const auto canLoop_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean canLoop_buf = {};
-    canLoop_buf.tag = canLoop_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((canLoop_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        canLoop_buf.value = valueDeserializer.readBoolean();
-    }
-    value.canLoop = canLoop_buf;
-    const auto disappearTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerTextStyle disappearTextStyle_buf = {};
-    disappearTextStyle_buf.tag = disappearTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((disappearTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        disappearTextStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
-    }
-    value.disappearTextStyle = disappearTextStyle_buf;
-    const auto textStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerTextStyle textStyle_buf = {};
-    textStyle_buf.tag = textStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((textStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        textStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
-    }
-    value.textStyle = textStyle_buf;
-    const auto acceptButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerDialogButtonStyle acceptButtonStyle_buf = {};
-    acceptButtonStyle_buf.tag = acceptButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((acceptButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        acceptButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
-    }
-    value.acceptButtonStyle = acceptButtonStyle_buf;
-    const auto cancelButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerDialogButtonStyle cancelButtonStyle_buf = {};
-    cancelButtonStyle_buf.tag = cancelButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((cancelButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        cancelButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
-    }
-    value.cancelButtonStyle = cancelButtonStyle_buf;
-    const auto selectedTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PickerTextStyle selectedTextStyle_buf = {};
-    selectedTextStyle_buf.tag = selectedTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((selectedTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        selectedTextStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
-    }
-    value.selectedTextStyle = selectedTextStyle_buf;
-    const auto disableTextStyleAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean disableTextStyleAnimation_buf = {};
-    disableTextStyleAnimation_buf.tag = disableTextStyleAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((disableTextStyleAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        disableTextStyleAnimation_buf.value = valueDeserializer.readBoolean();
-    }
-    value.disableTextStyleAnimation = disableTextStyleAnimation_buf;
-    const auto defaultTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TextPickerTextStyle defaultTextStyle_buf = {};
-    defaultTextStyle_buf.tag = defaultTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((defaultTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        defaultTextStyle_buf.value = TextPickerTextStyle_serializer::read(valueDeserializer);
     }
-    value.defaultTextStyle = defaultTextStyle_buf;
-    const auto onAccept_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_TextPickerResult_Void onAccept_buf = {};
-    onAccept_buf.tag = onAccept_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAccept_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onAccept_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
+    const auto value_maxFontSize = value.maxFontSize;
+    Ark_Int32 value_maxFontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maxFontSize_type = runtimeType(value_maxFontSize);
+    valueSerializer.writeInt8(value_maxFontSize_type);
+    if ((value_maxFontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maxFontSize_value = value_maxFontSize.value;
+        Ark_Int32 value_maxFontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_maxFontSize_value_type = value_maxFontSize_value.selector;
+        if (value_maxFontSize_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_maxFontSize_value_0 = value_maxFontSize_value.value0;
+            valueSerializer.writeNumber(value_maxFontSize_value_0);
+        }
+        else if (value_maxFontSize_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_maxFontSize_value_1 = value_maxFontSize_value.value1;
+            valueSerializer.writeString(value_maxFontSize_value_1);
+        }
+        else if (value_maxFontSize_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_maxFontSize_value_2 = value_maxFontSize_value.value2;
+            Resource_serializer::write(valueSerializer, value_maxFontSize_value_2);
+        }
     }
-    value.onAccept = onAccept_buf;
-    const auto onCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onCancel_buf = {};
-    onCancel_buf.tag = onCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onCancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    const auto value_overflow = value.overflow;
+    Ark_Int32 value_overflow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_overflow_type = runtimeType(value_overflow);
+    valueSerializer.writeInt8(value_overflow_type);
+    if ((value_overflow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_overflow_value = value_overflow.value;
+        valueSerializer.writeInt32(static_cast<Ark_TextOverflow>(value_overflow_value));
     }
-    value.onCancel = onCancel_buf;
-    const auto onChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_TextPickerResult_Void onChange_buf = {};
-    onChange_buf.tag = onChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+}
+inline Ark_TextPickerTextStyle TextPickerTextStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_TextPickerTextStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto color_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor color_buf = {};
+    color_buf.tag = color_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((color_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
+        const Ark_Int8 color_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor color_buf_ = {};
+        color_buf_.selector = color_buf__selector;
+        if (color_buf__selector == 0) {
+            color_buf_.selector = 0;
+            color_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (color_buf__selector == 1) {
+            color_buf_.selector = 1;
+            color_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (color_buf__selector == 2) {
+            color_buf_.selector = 2;
+            color_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (color_buf__selector == 3) {
+            color_buf_.selector = 3;
+            color_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for color_buf_ has to be chosen through deserialisation.");
+        }
+        color_buf.value = static_cast<Ark_ResourceColor>(color_buf_);
     }
-    value.onChange = onChange_buf;
-    const auto onScrollStop_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_TextPickerResult_Void onScrollStop_buf = {};
-    onScrollStop_buf.tag = onScrollStop_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onScrollStop_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.color = color_buf;
+    const auto font_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Font font_buf = {};
+    font_buf.tag = font_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((font_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onScrollStop_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
+        font_buf.value = Font_serializer::read(valueDeserializer);
     }
-    value.onScrollStop = onScrollStop_buf;
-    const auto onEnterSelectedArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_TextPickerResult_Void onEnterSelectedArea_buf = {};
-    onEnterSelectedArea_buf.tag = onEnterSelectedArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onEnterSelectedArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.font = font_buf;
+    const auto minFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_String_Resource minFontSize_buf = {};
+    minFontSize_buf.tag = minFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((minFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onEnterSelectedArea_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
+        const Ark_Int8 minFontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_String_Resource minFontSize_buf_ = {};
+        minFontSize_buf_.selector = minFontSize_buf__selector;
+        if (minFontSize_buf__selector == 0) {
+            minFontSize_buf_.selector = 0;
+            minFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (minFontSize_buf__selector == 1) {
+            minFontSize_buf_.selector = 1;
+            minFontSize_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (minFontSize_buf__selector == 2) {
+            minFontSize_buf_.selector = 2;
+            minFontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for minFontSize_buf_ has to be chosen through deserialisation.");
+        }
+        minFontSize_buf.value = static_cast<Ark_Union_Number_String_Resource>(minFontSize_buf_);
     }
-    value.onEnterSelectedArea = onEnterSelectedArea_buf;
-    const auto maskRect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Rectangle maskRect_buf = {};
-    maskRect_buf.tag = maskRect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((maskRect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.minFontSize = minFontSize_buf;
+    const auto maxFontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_String_Resource maxFontSize_buf = {};
+    maxFontSize_buf.tag = maxFontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maxFontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        maskRect_buf.value = Rectangle_serializer::read(valueDeserializer);
+        const Ark_Int8 maxFontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_String_Resource maxFontSize_buf_ = {};
+        maxFontSize_buf_.selector = maxFontSize_buf__selector;
+        if (maxFontSize_buf__selector == 0) {
+            maxFontSize_buf_.selector = 0;
+            maxFontSize_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (maxFontSize_buf__selector == 1) {
+            maxFontSize_buf_.selector = 1;
+            maxFontSize_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (maxFontSize_buf__selector == 2) {
+            maxFontSize_buf_.selector = 2;
+            maxFontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for maxFontSize_buf_ has to be chosen through deserialisation.");
+        }
+        maxFontSize_buf.value = static_cast<Ark_Union_Number_String_Resource>(maxFontSize_buf_);
     }
-    value.maskRect = maskRect_buf;
-    const auto alignment_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_DialogAlignment alignment_buf = {};
-    alignment_buf.tag = alignment_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((alignment_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.maxFontSize = maxFontSize_buf;
+    const auto overflow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextOverflow overflow_buf = {};
+    overflow_buf.tag = overflow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((overflow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        alignment_buf.value = static_cast<Ark_DialogAlignment>(valueDeserializer.readInt32());
+        overflow_buf.value = static_cast<Ark_TextOverflow>(valueDeserializer.readInt32());
     }
-    value.alignment = alignment_buf;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Offset offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        offset_buf.value = Offset_serializer::read(valueDeserializer);
+    value.overflow = overflow_buf;
+    return value;
+}
+inline void TouchEvent_serializer::write(SerializerBase& buffer, Ark_TouchEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_TouchEvent TouchEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_TouchEvent>(ptr);
+}
+inline void AccessibilityHoverEvent_serializer::write(SerializerBase& buffer, Ark_AccessibilityHoverEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_AccessibilityHoverEvent AccessibilityHoverEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_AccessibilityHoverEvent>(ptr);
+}
+inline void AxisEvent_serializer::write(SerializerBase& buffer, Ark_AxisEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_AxisEvent AxisEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_AxisEvent>(ptr);
+}
+inline void BackgroundColorStyle_serializer::write(SerializerBase& buffer, Ark_BackgroundColorStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_BackgroundColorStyle BackgroundColorStyle_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_BackgroundColorStyle>(ptr);
+}
+inline void BaseEvent_serializer::write(SerializerBase& buffer, Ark_BaseEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_BaseEvent BaseEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_BaseEvent>(ptr);
+}
+inline void BaseGestureEvent_serializer::write(SerializerBase& buffer, Ark_BaseGestureEvent value)
+{
+    SerializerBase& valueSerializer = buffer;
+    valueSerializer.writePointer(value);
+}
+inline Ark_BaseGestureEvent BaseGestureEvent_serializer::read(DeserializerBase& buffer)
+{
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_BaseGestureEvent>(ptr);
+}
+inline void BottomTabBarStyle_serializer::write(SerializerBase& buffer, Ark_BottomTabBarStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value__icon = value._icon;
+    Ark_Int32 value__icon_type = INTEROP_RUNTIME_UNDEFINED;
+    value__icon_type = runtimeType(value__icon);
+    valueSerializer.writeInt8(value__icon_type);
+    if ((value__icon_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__icon_value = value__icon.value;
+        Ark_Int32 value__icon_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__icon_value_type = value__icon_value.selector;
+        if ((value__icon_value_type == 0) || (value__icon_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value__icon_value_0 = value__icon_value.value0;
+            Ark_Int32 value__icon_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value__icon_value_0_type = value__icon_value_0.selector;
+            if (value__icon_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value__icon_value_0_0 = value__icon_value_0.value0;
+                valueSerializer.writeString(value__icon_value_0_0);
+            }
+            else if (value__icon_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value__icon_value_0_1 = value__icon_value_0.value1;
+                Resource_serializer::write(valueSerializer, value__icon_value_0_1);
+            }
+        }
+        else if (value__icon_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value__icon_value_1 = value__icon_value.value1;
+            TabBarSymbol_serializer::write(valueSerializer, value__icon_value_1);
+        }
     }
-    value.offset = offset_buf;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+    const auto value__text = value._text;
+    Ark_Int32 value__text_type = INTEROP_RUNTIME_UNDEFINED;
+    value__text_type = runtimeType(value__text);
+    valueSerializer.writeInt8(value__text_type);
+    if ((value__text_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__text_value = value__text.value;
+        Ark_Int32 value__text_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__text_value_type = value__text_value.selector;
+        if (value__text_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value__text_value_0 = value__text_value.value0;
+            valueSerializer.writeString(value__text_value_0);
         }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (value__text_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value__text_value_1 = value__text_value.value1;
+            Resource_serializer::write(valueSerializer, value__text_value_1);
         }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    const auto value__labelStyle = value._labelStyle;
+    Ark_Int32 value__labelStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value__labelStyle_type = runtimeType(value__labelStyle);
+    valueSerializer.writeInt8(value__labelStyle_type);
+    if ((value__labelStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__labelStyle_value = value__labelStyle.value;
+        TabBarLabelStyle_serializer::write(valueSerializer, value__labelStyle_value);
+    }
+    const auto value__padding = value._padding;
+    Ark_Int32 value__padding_type = INTEROP_RUNTIME_UNDEFINED;
+    value__padding_type = runtimeType(value__padding);
+    valueSerializer.writeInt8(value__padding_type);
+    if ((value__padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__padding_value = value__padding.value;
+        Ark_Int32 value__padding_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__padding_value_type = value__padding_value.selector;
+        if (value__padding_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value__padding_value_0 = value__padding_value.value0;
+            Padding_serializer::write(valueSerializer, value__padding_value_0);
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if ((value__padding_value_type == 1) || (value__padding_value_type == 1) || (value__padding_value_type == 1)) {
+            valueSerializer.writeInt8(1);
+            const auto value__padding_value_1 = value__padding_value.value1;
+            Ark_Int32 value__padding_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+            value__padding_value_1_type = value__padding_value_1.selector;
+            if (value__padding_value_1_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value__padding_value_1_0 = value__padding_value_1.value0;
+                valueSerializer.writeString(value__padding_value_1_0);
+            }
+            else if (value__padding_value_1_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value__padding_value_1_1 = value__padding_value_1.value1;
+                valueSerializer.writeNumber(value__padding_value_1_1);
+            }
+            else if (value__padding_value_1_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value__padding_value_1_2 = value__padding_value_1.value2;
+                Resource_serializer::write(valueSerializer, value__padding_value_1_2);
+            }
         }
-        else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        else if (value__padding_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value__padding_value_2 = value__padding_value.value2;
+            LocalizedPadding_serializer::write(valueSerializer, value__padding_value_2);
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-    value.backgroundColor = backgroundColor_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+    const auto value__layoutMode = value._layoutMode;
+    Ark_Int32 value__layoutMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value__layoutMode_type = runtimeType(value__layoutMode);
+    valueSerializer.writeInt8(value__layoutMode_type);
+    if ((value__layoutMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__layoutMode_value = value__layoutMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_LayoutMode>(value__layoutMode_value));
     }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
-    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
+    const auto value__verticalAlign = value._verticalAlign;
+    Ark_Int32 value__verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value__verticalAlign_type = runtimeType(value__verticalAlign);
+    valueSerializer.writeInt8(value__verticalAlign_type);
+    if ((value__verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__verticalAlign_value = value__verticalAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_VerticalAlign>(value__verticalAlign_value));
     }
-    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
-    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
-    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
+    const auto value__symmetricExtensible = value._symmetricExtensible;
+    Ark_Int32 value__symmetricExtensible_type = INTEROP_RUNTIME_UNDEFINED;
+    value__symmetricExtensible_type = runtimeType(value__symmetricExtensible);
+    valueSerializer.writeInt8(value__symmetricExtensible_type);
+    if ((value__symmetricExtensible_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__symmetricExtensible_value = value__symmetricExtensible.value;
+        valueSerializer.writeBoolean(value__symmetricExtensible_value);
     }
-    value.backgroundEffect = backgroundEffect_buf;
-    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDidAppear_buf = {};
-    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    const auto value__id = value._id;
+    Ark_Int32 value__id_type = INTEROP_RUNTIME_UNDEFINED;
+    value__id_type = runtimeType(value__id);
+    valueSerializer.writeInt8(value__id_type);
+    if ((value__id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__id_value = value__id.value;
+        valueSerializer.writeString(value__id_value);
     }
-    value.onDidAppear = onDidAppear_buf;
-    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDidDisappear_buf = {};
-    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto value__iconStyle = value._iconStyle;
+    Ark_Int32 value__iconStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value__iconStyle_type = runtimeType(value__iconStyle);
+    valueSerializer.writeInt8(value__iconStyle_type);
+    if ((value__iconStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__iconStyle_value = value__iconStyle.value;
+        TabBarIconStyle_serializer::write(valueSerializer, value__iconStyle_value);
+    }
+}
+inline Ark_BottomTabBarStyle BottomTabBarStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_BottomTabBarStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto _icon_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceStr_TabBarSymbol _icon_buf = {};
+    _icon_buf.tag = _icon_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_icon_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        const Ark_Int8 _icon_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceStr_TabBarSymbol _icon_buf_ = {};
+        _icon_buf_.selector = _icon_buf__selector;
+        if (_icon_buf__selector == 0) {
+            _icon_buf_.selector = 0;
+            const Ark_Int8 _icon_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceStr _icon_buf__u = {};
+            _icon_buf__u.selector = _icon_buf__u_selector;
+            if (_icon_buf__u_selector == 0) {
+                _icon_buf__u.selector = 0;
+                _icon_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (_icon_buf__u_selector == 1) {
+                _icon_buf__u.selector = 1;
+                _icon_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for _icon_buf__u has to be chosen through deserialisation.");
+            }
+            _icon_buf_.value0 = static_cast<Ark_ResourceStr>(_icon_buf__u);
+        }
+        else if (_icon_buf__selector == 1) {
+            _icon_buf_.selector = 1;
+            _icon_buf_.value1 = static_cast<Ark_TabBarSymbol>(TabBarSymbol_serializer::read(valueDeserializer));
+        }
+        else {
+            INTEROP_FATAL("One of the branches for _icon_buf_ has to be chosen through deserialisation.");
+        }
+        _icon_buf.value = static_cast<Ark_Union_ResourceStr_TabBarSymbol>(_icon_buf_);
     }
-    value.onDidDisappear = onDidDisappear_buf;
-    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillAppear_buf = {};
-    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._icon = _icon_buf;
+    const auto _text_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceStr _text_buf = {};
+    _text_buf.tag = _text_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_text_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        const Ark_Int8 _text_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceStr _text_buf_ = {};
+        _text_buf_.selector = _text_buf__selector;
+        if (_text_buf__selector == 0) {
+            _text_buf_.selector = 0;
+            _text_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (_text_buf__selector == 1) {
+            _text_buf_.selector = 1;
+            _text_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for _text_buf_ has to be chosen through deserialisation.");
+        }
+        _text_buf.value = static_cast<Ark_ResourceStr>(_text_buf_);
     }
-    value.onWillAppear = onWillAppear_buf;
-    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillDisappear_buf = {};
-    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._text = _text_buf;
+    const auto _labelStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TabBarLabelStyle _labelStyle_buf = {};
+    _labelStyle_buf.tag = _labelStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_labelStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        _labelStyle_buf.value = TabBarLabelStyle_serializer::read(valueDeserializer);
     }
-    value.onWillDisappear = onWillDisappear_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._labelStyle = _labelStyle_buf;
+    const auto _padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Padding_Dimension_LocalizedPadding _padding_buf = {};
+    _padding_buf.tag = _padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        const Ark_Int8 _padding_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Padding_Dimension_LocalizedPadding _padding_buf_ = {};
+        _padding_buf_.selector = _padding_buf__selector;
+        if (_padding_buf__selector == 0) {
+            _padding_buf_.selector = 0;
+            _padding_buf_.value0 = Padding_serializer::read(valueDeserializer);
+        }
+        else if (_padding_buf__selector == 1) {
+            _padding_buf_.selector = 1;
+            const Ark_Int8 _padding_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Dimension _padding_buf__u = {};
+            _padding_buf__u.selector = _padding_buf__u_selector;
+            if (_padding_buf__u_selector == 0) {
+                _padding_buf__u.selector = 0;
+                _padding_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (_padding_buf__u_selector == 1) {
+                _padding_buf__u.selector = 1;
+                _padding_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (_padding_buf__u_selector == 2) {
+                _padding_buf__u.selector = 2;
+                _padding_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for _padding_buf__u has to be chosen through deserialisation.");
+            }
+            _padding_buf_.value1 = static_cast<Ark_Dimension>(_padding_buf__u);
         }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        else if (_padding_buf__selector == 2) {
+            _padding_buf_.selector = 2;
+            _padding_buf_.value2 = LocalizedPadding_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _padding_buf_ has to be chosen through deserialisation.");
         }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+        _padding_buf.value = static_cast<Ark_Union_Padding_Dimension_LocalizedPadding>(_padding_buf_);
     }
-    value.shadow = shadow_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._padding = _padding_buf;
+    const auto _layoutMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_LayoutMode _layoutMode_buf = {};
+    _layoutMode_buf.tag = _layoutMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_layoutMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+        _layoutMode_buf.value = static_cast<Ark_LayoutMode>(valueDeserializer.readInt32());
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HoverModeAreaType hoverModeArea_buf = {};
-    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._layoutMode = _layoutMode_buf;
+    const auto _verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VerticalAlign _verticalAlign_buf = {};
+    _verticalAlign_buf.tag = _verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
+        _verticalAlign_buf.value = static_cast<Ark_VerticalAlign>(valueDeserializer.readInt32());
     }
-    value.hoverModeArea = hoverModeArea_buf;
-    const auto enableHapticFeedback_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHapticFeedback_buf = {};
-    enableHapticFeedback_buf.tag = enableHapticFeedback_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHapticFeedback_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._verticalAlign = _verticalAlign_buf;
+    const auto _symmetricExtensible_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean _symmetricExtensible_buf = {};
+    _symmetricExtensible_buf.tag = _symmetricExtensible_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_symmetricExtensible_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHapticFeedback_buf.value = valueDeserializer.readBoolean();
+        _symmetricExtensible_buf.value = valueDeserializer.readBoolean();
     }
-    value.enableHapticFeedback = enableHapticFeedback_buf;
+    value._symmetricExtensible = _symmetricExtensible_buf;
+    const auto _id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String _id_buf = {};
+    _id_buf.tag = _id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    value._id = _id_buf;
+    const auto _iconStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TabBarIconStyle _iconStyle_buf = {};
+    _iconStyle_buf.tag = _iconStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_iconStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _iconStyle_buf.value = TabBarIconStyle_serializer::read(valueDeserializer);
+    }
+    value._iconStyle = _iconStyle_buf;
     return value;
 }
-inline void RichEditorImageSpanOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanOptions value)
+inline void CalendarDialogOptions_serializer::write(SerializerBase& buffer, Ark_CalendarDialogOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        valueSerializer.writeNumber(value_offset_value);
+    const auto value_hintRadius = value.hintRadius;
+    Ark_Int32 value_hintRadius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hintRadius_type = runtimeType(value_hintRadius);
+    valueSerializer.writeInt8(value_hintRadius_type);
+    if ((value_hintRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hintRadius_value = value_hintRadius.value;
+        Ark_Int32 value_hintRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_hintRadius_value_type = value_hintRadius_value.selector;
+        if (value_hintRadius_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_hintRadius_value_0 = value_hintRadius_value.value0;
+            valueSerializer.writeNumber(value_hintRadius_value_0);
+        }
+        else if (value_hintRadius_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_hintRadius_value_1 = value_hintRadius_value.value1;
+            Resource_serializer::write(valueSerializer, value_hintRadius_value_1);
+        }
     }
-    const auto value_imageStyle = value.imageStyle;
-    Ark_Int32 value_imageStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_imageStyle_type = runtimeType(value_imageStyle);
-    valueSerializer.writeInt8(value_imageStyle_type);
-    if ((value_imageStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_imageStyle_value = value_imageStyle.value;
-        RichEditorImageSpanStyle_serializer::write(valueSerializer, value_imageStyle_value);
+    const auto value_selected = value.selected;
+    Ark_Int32 value_selected_type = INTEROP_RUNTIME_UNDEFINED;
+    value_selected_type = runtimeType(value_selected);
+    valueSerializer.writeInt8(value_selected_type);
+    if ((value_selected_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_selected_value = value_selected.value;
+        valueSerializer.writeInt64(value_selected_value);
     }
-    const auto value_gesture = value.gesture;
-    Ark_Int32 value_gesture_type = INTEROP_RUNTIME_UNDEFINED;
-    value_gesture_type = runtimeType(value_gesture);
-    valueSerializer.writeInt8(value_gesture_type);
-    if ((value_gesture_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_gesture_value = value_gesture.value;
-        RichEditorGesture_serializer::write(valueSerializer, value_gesture_value);
+    const auto value_start = value.start;
+    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
+    value_start_type = runtimeType(value_start);
+    valueSerializer.writeInt8(value_start_type);
+    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_start_value = value_start.value;
+        valueSerializer.writeInt64(value_start_value);
     }
-    const auto value_onHover = value.onHover;
-    Ark_Int32 value_onHover_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onHover_type = runtimeType(value_onHover);
-    valueSerializer.writeInt8(value_onHover_type);
-    if ((value_onHover_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onHover_value = value_onHover.value;
-        valueSerializer.writeCallbackResource(value_onHover_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHover_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHover_value.callSync));
+    const auto value_end = value.end;
+    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
+    value_end_type = runtimeType(value_end);
+    valueSerializer.writeInt8(value_end_type);
+    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_end_value = value_end.value;
+        valueSerializer.writeInt64(value_end_value);
     }
-}
-inline Ark_RichEditorImageSpanOptions RichEditorImageSpanOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorImageSpanOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        offset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    const auto value_disabledDateRange = value.disabledDateRange;
+    Ark_Int32 value_disabledDateRange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_disabledDateRange_type = runtimeType(value_disabledDateRange);
+    valueSerializer.writeInt8(value_disabledDateRange_type);
+    if ((value_disabledDateRange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_disabledDateRange_value = value_disabledDateRange.value;
+        valueSerializer.writeInt32(value_disabledDateRange_value.length);
+        for (int value_disabledDateRange_value_counter_i = 0; value_disabledDateRange_value_counter_i < value_disabledDateRange_value.length; value_disabledDateRange_value_counter_i++) {
+            const Ark_DateRange value_disabledDateRange_value_element = value_disabledDateRange_value.array[value_disabledDateRange_value_counter_i];
+            DateRange_serializer::write(valueSerializer, value_disabledDateRange_value_element);
+        }
     }
-    value.offset = offset_buf;
-    const auto imageStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorImageSpanStyle imageStyle_buf = {};
-    imageStyle_buf.tag = imageStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((imageStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        imageStyle_buf.value = RichEditorImageSpanStyle_serializer::read(valueDeserializer);
+    const auto value_onAccept = value.onAccept;
+    Ark_Int32 value_onAccept_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onAccept_type = runtimeType(value_onAccept);
+    valueSerializer.writeInt8(value_onAccept_type);
+    if ((value_onAccept_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onAccept_value = value_onAccept.value;
+        valueSerializer.writeCallbackResource(value_onAccept_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.callSync));
     }
-    value.imageStyle = imageStyle_buf;
-    const auto gesture_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorGesture gesture_buf = {};
-    gesture_buf.tag = gesture_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((gesture_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        gesture_buf.value = RichEditorGesture_serializer::read(valueDeserializer);
+    const auto value_onCancel = value.onCancel;
+    Ark_Int32 value_onCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onCancel_type = runtimeType(value_onCancel);
+    valueSerializer.writeInt8(value_onCancel_type);
+    if ((value_onCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onCancel_value = value_onCancel.value;
+        valueSerializer.writeCallbackResource(value_onCancel_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.callSync));
     }
-    value.gesture = gesture_buf;
-    const auto onHover_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_OnHoverCallback onHover_buf = {};
-    onHover_buf.tag = onHover_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onHover_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onHover_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Boolean status, const Ark_HoverEvent event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_OnHoverCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Boolean status, const Ark_HoverEvent event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_OnHoverCallback))))};
+    const auto value_onChange = value.onChange;
+    Ark_Int32 value_onChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onChange_type = runtimeType(value_onChange);
+    valueSerializer.writeInt8(value_onChange_type);
+    if ((value_onChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onChange_value = value_onChange.value;
+        valueSerializer.writeCallbackResource(value_onChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.callSync));
     }
-    value.onHover = onHover_buf;
-    return value;
-}
-inline void RichEditorImageSpanResult_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanResult value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_spanPosition = value.spanPosition;
-    RichEditorSpanPosition_serializer::write(valueSerializer, value_spanPosition);
-    const auto value_valuePixelMap = value.valuePixelMap;
-    Ark_Int32 value_valuePixelMap_type = INTEROP_RUNTIME_UNDEFINED;
-    value_valuePixelMap_type = runtimeType(value_valuePixelMap);
-    valueSerializer.writeInt8(value_valuePixelMap_type);
-    if ((value_valuePixelMap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_valuePixelMap_value = value_valuePixelMap.value;
-        image_PixelMap_serializer::write(valueSerializer, value_valuePixelMap_value);
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+        }
+        else if (value_backgroundColor_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
+        }
+        else if (value_backgroundColor_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
+        }
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+        }
     }
-    const auto value_valueResourceStr = value.valueResourceStr;
-    Ark_Int32 value_valueResourceStr_type = INTEROP_RUNTIME_UNDEFINED;
-    value_valueResourceStr_type = runtimeType(value_valueResourceStr);
-    valueSerializer.writeInt8(value_valueResourceStr_type);
-    if ((value_valueResourceStr_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_valueResourceStr_value = value_valueResourceStr.value;
-        Ark_Int32 value_valueResourceStr_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_valueResourceStr_value_type = value_valueResourceStr_value.selector;
-        if (value_valueResourceStr_value_type == 0) {
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
+    }
+    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
+    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
+    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
+    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
+        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
+    }
+    const auto value_backgroundEffect = value.backgroundEffect;
+    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
+    valueSerializer.writeInt8(value_backgroundEffect_type);
+    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundEffect_value = value_backgroundEffect.value;
+        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
+    }
+    const auto value_acceptButtonStyle = value.acceptButtonStyle;
+    Ark_Int32 value_acceptButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_acceptButtonStyle_type = runtimeType(value_acceptButtonStyle);
+    valueSerializer.writeInt8(value_acceptButtonStyle_type);
+    if ((value_acceptButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_acceptButtonStyle_value = value_acceptButtonStyle.value;
+        PickerDialogButtonStyle_serializer::write(valueSerializer, value_acceptButtonStyle_value);
+    }
+    const auto value_cancelButtonStyle = value.cancelButtonStyle;
+    Ark_Int32 value_cancelButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_cancelButtonStyle_type = runtimeType(value_cancelButtonStyle);
+    valueSerializer.writeInt8(value_cancelButtonStyle_type);
+    if ((value_cancelButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_cancelButtonStyle_value = value_cancelButtonStyle.value;
+        PickerDialogButtonStyle_serializer::write(valueSerializer, value_cancelButtonStyle_value);
+    }
+    const auto value_onDidAppear = value.onDidAppear;
+    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidAppear_type = runtimeType(value_onDidAppear);
+    valueSerializer.writeInt8(value_onDidAppear_type);
+    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidAppear_value = value_onDidAppear.value;
+        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
+    }
+    const auto value_onDidDisappear = value.onDidDisappear;
+    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
+    valueSerializer.writeInt8(value_onDidDisappear_type);
+    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidDisappear_value = value_onDidDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
+    }
+    const auto value_onWillAppear = value.onWillAppear;
+    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillAppear_type = runtimeType(value_onWillAppear);
+    valueSerializer.writeInt8(value_onWillAppear_type);
+    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillAppear_value = value_onWillAppear.value;
+        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    }
+    const auto value_onWillDisappear = value.onWillDisappear;
+    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
+    valueSerializer.writeInt8(value_onWillDisappear_type);
+    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDisappear_value = value_onWillDisappear.value;
+        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+    }
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_valueResourceStr_value_0 = value_valueResourceStr_value.value0;
-            valueSerializer.writeString(value_valueResourceStr_value_0);
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
         }
-        else if (value_valueResourceStr_value_type == 1) {
+        else if (value_shadow_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_valueResourceStr_value_1 = value_valueResourceStr_value.value1;
-            Resource_serializer::write(valueSerializer, value_valueResourceStr_value_1);
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
     }
-    const auto value_imageStyle = value.imageStyle;
-    RichEditorImageSpanStyleResult_serializer::write(valueSerializer, value_imageStyle);
-    const auto value_offsetInSpan = value.offsetInSpan;
-    const auto value_offsetInSpan_0 = value_offsetInSpan.value0;
-    valueSerializer.writeNumber(value_offsetInSpan_0);
-    const auto value_offsetInSpan_1 = value_offsetInSpan.value1;
-    valueSerializer.writeNumber(value_offsetInSpan_1);
+    const auto value_enableHoverMode = value.enableHoverMode;
+    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
+    valueSerializer.writeInt8(value_enableHoverMode_type);
+    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHoverMode_value = value_enableHoverMode.value;
+        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    }
+    const auto value_hoverModeArea = value.hoverModeArea;
+    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
+    valueSerializer.writeInt8(value_hoverModeArea_type);
+    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hoverModeArea_value = value_hoverModeArea.value;
+        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
+    }
+    const auto value_markToday = value.markToday;
+    Ark_Int32 value_markToday_type = INTEROP_RUNTIME_UNDEFINED;
+    value_markToday_type = runtimeType(value_markToday);
+    valueSerializer.writeInt8(value_markToday_type);
+    if ((value_markToday_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_markToday_value = value_markToday.value;
+        valueSerializer.writeBoolean(value_markToday_value);
+    }
 }
-inline Ark_RichEditorImageSpanResult RichEditorImageSpanResult_serializer::read(DeserializerBase& buffer)
+inline Ark_CalendarDialogOptions CalendarDialogOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_RichEditorImageSpanResult value = {};
+    Ark_CalendarDialogOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.spanPosition = RichEditorSpanPosition_serializer::read(valueDeserializer);
-    const auto valuePixelMap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_image_PixelMap valuePixelMap_buf = {};
-    valuePixelMap_buf.tag = valuePixelMap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((valuePixelMap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        valuePixelMap_buf.value = static_cast<Ark_image_PixelMap>(image_PixelMap_serializer::read(valueDeserializer));
-    }
-    value.valuePixelMap = valuePixelMap_buf;
-    const auto valueResourceStr_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceStr valueResourceStr_buf = {};
-    valueResourceStr_buf.tag = valueResourceStr_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((valueResourceStr_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto hintRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_Resource hintRadius_buf = {};
+    hintRadius_buf.tag = hintRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hintRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 valueResourceStr_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceStr valueResourceStr_buf_ = {};
-        valueResourceStr_buf_.selector = valueResourceStr_buf__selector;
-        if (valueResourceStr_buf__selector == 0) {
-            valueResourceStr_buf_.selector = 0;
-            valueResourceStr_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 hintRadius_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_Resource hintRadius_buf_ = {};
+        hintRadius_buf_.selector = hintRadius_buf__selector;
+        if (hintRadius_buf__selector == 0) {
+            hintRadius_buf_.selector = 0;
+            hintRadius_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (valueResourceStr_buf__selector == 1) {
-            valueResourceStr_buf_.selector = 1;
-            valueResourceStr_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (hintRadius_buf__selector == 1) {
+            hintRadius_buf_.selector = 1;
+            hintRadius_buf_.value1 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for valueResourceStr_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for hintRadius_buf_ has to be chosen through deserialisation.");
         }
-        valueResourceStr_buf.value = static_cast<Ark_ResourceStr>(valueResourceStr_buf_);
+        hintRadius_buf.value = static_cast<Ark_Union_Number_Resource>(hintRadius_buf_);
     }
-    value.valueResourceStr = valueResourceStr_buf;
-    value.imageStyle = RichEditorImageSpanStyleResult_serializer::read(valueDeserializer);
-    Ark_Tuple_Number_Number offsetInSpan_buf = {};
-    offsetInSpan_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    offsetInSpan_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.offsetInSpan = offsetInSpan_buf;
-    return value;
-}
-inline void RichEditorTextSpanOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorTextSpanOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        valueSerializer.writeNumber(value_offset_value);
+    value.hintRadius = hintRadius_buf;
+    const auto selected_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Date selected_buf = {};
+    selected_buf.tag = selected_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((selected_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        selected_buf.value = valueDeserializer.readInt64();
     }
-    const auto value_style = value.style;
-    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
-    value_style_type = runtimeType(value_style);
-    valueSerializer.writeInt8(value_style_type);
-    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_style_value = value_style.value;
-        RichEditorTextStyle_serializer::write(valueSerializer, value_style_value);
+    value.selected = selected_buf;
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Date start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        start_buf.value = valueDeserializer.readInt64();
     }
-    const auto value_paragraphStyle = value.paragraphStyle;
-    Ark_Int32 value_paragraphStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_paragraphStyle_type = runtimeType(value_paragraphStyle);
-    valueSerializer.writeInt8(value_paragraphStyle_type);
-    if ((value_paragraphStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_paragraphStyle_value = value_paragraphStyle.value;
-        RichEditorParagraphStyle_serializer::write(valueSerializer, value_paragraphStyle_value);
+    value.start = start_buf;
+    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Date end_buf = {};
+    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        end_buf.value = valueDeserializer.readInt64();
+    }
+    value.end = end_buf;
+    const auto disabledDateRange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Array_DateRange disabledDateRange_buf = {};
+    disabledDateRange_buf.tag = disabledDateRange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((disabledDateRange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int32 disabledDateRange_buf__length = valueDeserializer.readInt32();
+        Array_DateRange disabledDateRange_buf_ = {};
+        valueDeserializer.resizeArray<std::decay<decltype(disabledDateRange_buf_)>::type,
+        std::decay<decltype(*disabledDateRange_buf_.array)>::type>(&disabledDateRange_buf_, disabledDateRange_buf__length);
+        for (int disabledDateRange_buf__i = 0; disabledDateRange_buf__i < disabledDateRange_buf__length; disabledDateRange_buf__i++) {
+            disabledDateRange_buf_.array[disabledDateRange_buf__i] = DateRange_serializer::read(valueDeserializer);
+        }
+        disabledDateRange_buf.value = disabledDateRange_buf_;
     }
-    const auto value_gesture = value.gesture;
-    Ark_Int32 value_gesture_type = INTEROP_RUNTIME_UNDEFINED;
-    value_gesture_type = runtimeType(value_gesture);
-    valueSerializer.writeInt8(value_gesture_type);
-    if ((value_gesture_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_gesture_value = value_gesture.value;
-        RichEditorGesture_serializer::write(valueSerializer, value_gesture_value);
+    value.disabledDateRange = disabledDateRange_buf;
+    const auto onAccept_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Date_Void onAccept_buf = {};
+    onAccept_buf.tag = onAccept_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAccept_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onAccept_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Date_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Date_Void))))};
     }
-    const auto value_urlStyle = value.urlStyle;
-    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_urlStyle_type = runtimeType(value_urlStyle);
-    valueSerializer.writeInt8(value_urlStyle_type);
-    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_urlStyle_value = value_urlStyle.value;
-        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
+    value.onAccept = onAccept_buf;
+    const auto onCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VoidCallback onCancel_buf = {};
+    onCancel_buf.tag = onCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onCancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
     }
-}
-inline Ark_RichEditorTextSpanOptions RichEditorTextSpanOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorTextSpanOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Number offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onCancel = onCancel_buf;
+    const auto onChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Date_Void onChange_buf = {};
+    onChange_buf.tag = onChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        onChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Date_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Date value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Date_Void))))};
     }
-    value.offset = offset_buf;
-    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorTextStyle style_buf = {};
-    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onChange = onChange_buf;
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        style_buf.value = RichEditorTextStyle_serializer::read(valueDeserializer);
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        }
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-    value.style = style_buf;
-    const auto paragraphStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorParagraphStyle paragraphStyle_buf = {};
-    paragraphStyle_buf.tag = paragraphStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((paragraphStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundColor = backgroundColor_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        paragraphStyle_buf.value = RichEditorParagraphStyle_serializer::read(valueDeserializer);
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    value.paragraphStyle = paragraphStyle_buf;
-    const auto gesture_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorGesture gesture_buf = {};
-    gesture_buf.tag = gesture_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((gesture_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
+    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        gesture_buf.value = RichEditorGesture_serializer::read(valueDeserializer);
+        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
     }
-    value.gesture = gesture_buf;
-    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorUrlStyle urlStyle_buf = {};
-    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
+    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
+    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
+        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
     }
-    value.urlStyle = urlStyle_buf;
-    return value;
-}
-inline void RichEditorTextSpanResult_serializer::write(SerializerBase& buffer, Ark_RichEditorTextSpanResult value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_spanPosition = value.spanPosition;
-    RichEditorSpanPosition_serializer::write(valueSerializer, value_spanPosition);
-    const auto value_value = value.value;
-    valueSerializer.writeString(value_value);
-    const auto value_textStyle = value.textStyle;
-    RichEditorTextStyleResult_serializer::write(valueSerializer, value_textStyle);
-    const auto value_offsetInSpan = value.offsetInSpan;
-    const auto value_offsetInSpan_0 = value_offsetInSpan.value0;
-    valueSerializer.writeNumber(value_offsetInSpan_0);
-    const auto value_offsetInSpan_1 = value_offsetInSpan.value1;
-    valueSerializer.writeNumber(value_offsetInSpan_1);
-    const auto value_symbolSpanStyle = value.symbolSpanStyle;
-    Ark_Int32 value_symbolSpanStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_symbolSpanStyle_type = runtimeType(value_symbolSpanStyle);
-    valueSerializer.writeInt8(value_symbolSpanStyle_type);
-    if ((value_symbolSpanStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_symbolSpanStyle_value = value_symbolSpanStyle.value;
-        RichEditorSymbolSpanStyle_serializer::write(valueSerializer, value_symbolSpanStyle_value);
+    value.backgroundEffect = backgroundEffect_buf;
+    const auto acceptButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerDialogButtonStyle acceptButtonStyle_buf = {};
+    acceptButtonStyle_buf.tag = acceptButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((acceptButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        acceptButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
     }
-    const auto value_valueResource = value.valueResource;
-    Ark_Int32 value_valueResource_type = INTEROP_RUNTIME_UNDEFINED;
-    value_valueResource_type = runtimeType(value_valueResource);
-    valueSerializer.writeInt8(value_valueResource_type);
-    if ((value_valueResource_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_valueResource_value = value_valueResource.value;
-        Resource_serializer::write(valueSerializer, value_valueResource_value);
+    value.acceptButtonStyle = acceptButtonStyle_buf;
+    const auto cancelButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerDialogButtonStyle cancelButtonStyle_buf = {};
+    cancelButtonStyle_buf.tag = cancelButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((cancelButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        cancelButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
     }
-    const auto value_paragraphStyle = value.paragraphStyle;
-    Ark_Int32 value_paragraphStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_paragraphStyle_type = runtimeType(value_paragraphStyle);
-    valueSerializer.writeInt8(value_paragraphStyle_type);
-    if ((value_paragraphStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_paragraphStyle_value = value_paragraphStyle.value;
-        RichEditorParagraphStyle_serializer::write(valueSerializer, value_paragraphStyle_value);
+    value.cancelButtonStyle = cancelButtonStyle_buf;
+    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VoidCallback onDidAppear_buf = {};
+    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
     }
-    const auto value_previewText = value.previewText;
-    Ark_Int32 value_previewText_type = INTEROP_RUNTIME_UNDEFINED;
-    value_previewText_type = runtimeType(value_previewText);
-    valueSerializer.writeInt8(value_previewText_type);
-    if ((value_previewText_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_previewText_value = value_previewText.value;
-        valueSerializer.writeString(value_previewText_value);
+    value.onDidAppear = onDidAppear_buf;
+    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VoidCallback onDidDisappear_buf = {};
+    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
     }
-    const auto value_urlStyle = value.urlStyle;
-    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_urlStyle_type = runtimeType(value_urlStyle);
-    valueSerializer.writeInt8(value_urlStyle_type);
-    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_urlStyle_value = value_urlStyle.value;
-        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
+    value.onDidDisappear = onDidDisappear_buf;
+    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VoidCallback onWillAppear_buf = {};
+    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
     }
-}
-inline Ark_RichEditorTextSpanResult RichEditorTextSpanResult_serializer::read(DeserializerBase& buffer)
-{
-    Ark_RichEditorTextSpanResult value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    value.spanPosition = RichEditorSpanPosition_serializer::read(valueDeserializer);
-    value.value = static_cast<Ark_String>(valueDeserializer.readString());
-    value.textStyle = RichEditorTextStyleResult_serializer::read(valueDeserializer);
-    Ark_Tuple_Number_Number offsetInSpan_buf = {};
-    offsetInSpan_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    offsetInSpan_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.offsetInSpan = offsetInSpan_buf;
-    const auto symbolSpanStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorSymbolSpanStyle symbolSpanStyle_buf = {};
-    symbolSpanStyle_buf.tag = symbolSpanStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((symbolSpanStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillAppear = onWillAppear_buf;
+    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_VoidCallback onWillDisappear_buf = {};
+    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        symbolSpanStyle_buf.value = RichEditorSymbolSpanStyle_serializer::read(valueDeserializer);
+        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_VoidCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_VoidCallback))))};
     }
-    value.symbolSpanStyle = symbolSpanStyle_buf;
-    const auto valueResource_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Resource valueResource_buf = {};
-    valueResource_buf.tag = valueResource_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((valueResource_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.onWillDisappear = onWillDisappear_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        valueResource_buf.value = Resource_serializer::read(valueDeserializer);
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        }
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+        }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
-    value.valueResource = valueResource_buf;
-    const auto paragraphStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorParagraphStyle paragraphStyle_buf = {};
-    paragraphStyle_buf.tag = paragraphStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((paragraphStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.shadow = shadow_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        paragraphStyle_buf.value = RichEditorParagraphStyle_serializer::read(valueDeserializer);
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
-    value.paragraphStyle = paragraphStyle_buf;
-    const auto previewText_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_String previewText_buf = {};
-    previewText_buf.tag = previewText_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((previewText_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HoverModeAreaType hoverModeArea_buf = {};
+    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        previewText_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
     }
-    value.previewText = previewText_buf;
-    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_RichEditorUrlStyle urlStyle_buf = {};
-    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.hoverModeArea = hoverModeArea_buf;
+    const auto markToday_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean markToday_buf = {};
+    markToday_buf.tag = markToday_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((markToday_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
+        markToday_buf.value = valueDeserializer.readBoolean();
     }
-    value.urlStyle = urlStyle_buf;
+    value.markToday = markToday_buf;
     return value;
 }
-inline void SpanStyle_serializer::write(SerializerBase& buffer, Ark_SpanStyle value)
+inline void ClickEvent_serializer::write(SerializerBase& buffer, Ark_ClickEvent value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_start = value.start;
-    valueSerializer.writeNumber(value_start);
-    const auto value_length = value.length;
-    valueSerializer.writeNumber(value_length);
-    const auto value_styledKey = value.styledKey;
-    valueSerializer.writeInt32(static_cast<Ark_StyledStringKey>(value_styledKey));
-    const auto value_styledValue = value.styledValue;
-    Ark_Int32 value_styledValue_type = INTEROP_RUNTIME_UNDEFINED;
-    value_styledValue_type = value_styledValue.selector;
-    if (value_styledValue_type == 0) {
-        valueSerializer.writeInt8(0);
-        const auto value_styledValue_0 = value_styledValue.value0;
-        TextStyle_serializer::write(valueSerializer, value_styledValue_0);
-    }
-    else if (value_styledValue_type == 1) {
-        valueSerializer.writeInt8(1);
-        const auto value_styledValue_1 = value_styledValue.value1;
-        DecorationStyle_serializer::write(valueSerializer, value_styledValue_1);
-    }
-    else if (value_styledValue_type == 2) {
-        valueSerializer.writeInt8(2);
-        const auto value_styledValue_2 = value_styledValue.value2;
-        BaselineOffsetStyle_serializer::write(valueSerializer, value_styledValue_2);
-    }
-    else if (value_styledValue_type == 3) {
-        valueSerializer.writeInt8(3);
-        const auto value_styledValue_3 = value_styledValue.value3;
-        LetterSpacingStyle_serializer::write(valueSerializer, value_styledValue_3);
-    }
-    else if (value_styledValue_type == 4) {
-        valueSerializer.writeInt8(4);
-        const auto value_styledValue_4 = value_styledValue.value4;
-        TextShadowStyle_serializer::write(valueSerializer, value_styledValue_4);
-    }
-    else if (value_styledValue_type == 5) {
-        valueSerializer.writeInt8(5);
-        const auto value_styledValue_5 = value_styledValue.value5;
-        GestureStyle_serializer::write(valueSerializer, value_styledValue_5);
-    }
-    else if (value_styledValue_type == 6) {
-        valueSerializer.writeInt8(6);
-        const auto value_styledValue_6 = value_styledValue.value6;
-        ImageAttachment_serializer::write(valueSerializer, value_styledValue_6);
-    }
-    else if (value_styledValue_type == 7) {
-        valueSerializer.writeInt8(7);
-        const auto value_styledValue_7 = value_styledValue.value7;
-        ParagraphStyle_serializer::write(valueSerializer, value_styledValue_7);
-    }
-    else if (value_styledValue_type == 8) {
-        valueSerializer.writeInt8(8);
-        const auto value_styledValue_8 = value_styledValue.value8;
-        LineHeightStyle_serializer::write(valueSerializer, value_styledValue_8);
-    }
-    else if (value_styledValue_type == 9) {
-        valueSerializer.writeInt8(9);
-        const auto value_styledValue_9 = value_styledValue.value9;
-        UrlStyle_serializer::write(valueSerializer, value_styledValue_9);
-    }
-    else if (value_styledValue_type == 10) {
-        valueSerializer.writeInt8(10);
-        const auto value_styledValue_10 = value_styledValue.value10;
-        CustomSpan_serializer::write(valueSerializer, value_styledValue_10);
-    }
-    else if (value_styledValue_type == 11) {
-        valueSerializer.writeInt8(11);
-        const auto value_styledValue_11 = value_styledValue.value11;
-        UserDataSpan_serializer::write(valueSerializer, value_styledValue_11);
-    }
-    else if (value_styledValue_type == 12) {
-        valueSerializer.writeInt8(12);
-        const auto value_styledValue_12 = value_styledValue.value12;
-        BackgroundColorStyle_serializer::write(valueSerializer, value_styledValue_12);
-    }
+    valueSerializer.writePointer(value);
 }
-inline Ark_SpanStyle SpanStyle_serializer::read(DeserializerBase& buffer)
+inline Ark_ClickEvent ClickEvent_serializer::read(DeserializerBase& buffer)
 {
-    Ark_SpanStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.start = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.length = static_cast<Ark_Number>(valueDeserializer.readNumber());
-    value.styledKey = static_cast<Ark_StyledStringKey>(valueDeserializer.readInt32());
-    const Ark_Int8 styledValue_buf_selector = valueDeserializer.readInt8();
-    Ark_StyledStringValue styledValue_buf = {};
-    styledValue_buf.selector = styledValue_buf_selector;
-    if (styledValue_buf_selector == 0) {
-        styledValue_buf.selector = 0;
-        styledValue_buf.value0 = static_cast<Ark_TextStyle>(TextStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 1) {
-        styledValue_buf.selector = 1;
-        styledValue_buf.value1 = static_cast<Ark_DecorationStyle>(DecorationStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 2) {
-        styledValue_buf.selector = 2;
-        styledValue_buf.value2 = static_cast<Ark_BaselineOffsetStyle>(BaselineOffsetStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 3) {
-        styledValue_buf.selector = 3;
-        styledValue_buf.value3 = static_cast<Ark_LetterSpacingStyle>(LetterSpacingStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 4) {
-        styledValue_buf.selector = 4;
-        styledValue_buf.value4 = static_cast<Ark_TextShadowStyle>(TextShadowStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 5) {
-        styledValue_buf.selector = 5;
-        styledValue_buf.value5 = static_cast<Ark_GestureStyle>(GestureStyle_serializer::read(valueDeserializer));
-    }
-    else if (styledValue_buf_selector == 6) {
-        styledValue_buf.selector = 6;
-        styledValue_buf.value6 = static_cast<Ark_ImageAttachment>(ImageAttachment_serializer::read(valueDeserializer));
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_ClickEvent>(ptr);
+}
+inline void GridRowOptions_serializer::write(SerializerBase& buffer, Ark_GridRowOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_gutter = value.gutter;
+    Ark_Int32 value_gutter_type = INTEROP_RUNTIME_UNDEFINED;
+    value_gutter_type = runtimeType(value_gutter);
+    valueSerializer.writeInt8(value_gutter_type);
+    if ((value_gutter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_gutter_value = value_gutter.value;
+        Ark_Int32 value_gutter_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_gutter_value_type = value_gutter_value.selector;
+        if ((value_gutter_value_type == 0) || (value_gutter_value_type == 0) || (value_gutter_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value_gutter_value_0 = value_gutter_value.value0;
+            Ark_Int32 value_gutter_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_gutter_value_0_type = value_gutter_value_0.selector;
+            if (value_gutter_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_gutter_value_0_0 = value_gutter_value_0.value0;
+                valueSerializer.writeString(value_gutter_value_0_0);
+            }
+            else if (value_gutter_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_gutter_value_0_1 = value_gutter_value_0.value1;
+                valueSerializer.writeNumber(value_gutter_value_0_1);
+            }
+            else if (value_gutter_value_0_type == 2) {
+                valueSerializer.writeInt8(2);
+                const auto value_gutter_value_0_2 = value_gutter_value_0.value2;
+                Resource_serializer::write(valueSerializer, value_gutter_value_0_2);
+            }
+        }
+        else if (value_gutter_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_gutter_value_1 = value_gutter_value.value1;
+            GutterOption_serializer::write(valueSerializer, value_gutter_value_1);
+        }
     }
-    else if (styledValue_buf_selector == 7) {
-        styledValue_buf.selector = 7;
-        styledValue_buf.value7 = static_cast<Ark_ParagraphStyle>(ParagraphStyle_serializer::read(valueDeserializer));
+    const auto value_columns = value.columns;
+    Ark_Int32 value_columns_type = INTEROP_RUNTIME_UNDEFINED;
+    value_columns_type = runtimeType(value_columns);
+    valueSerializer.writeInt8(value_columns_type);
+    if ((value_columns_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_columns_value = value_columns.value;
+        Ark_Int32 value_columns_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_columns_value_type = value_columns_value.selector;
+        if (value_columns_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_columns_value_0 = value_columns_value.value0;
+            valueSerializer.writeNumber(value_columns_value_0);
+        }
+        else if (value_columns_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_columns_value_1 = value_columns_value.value1;
+            GridRowColumnOption_serializer::write(valueSerializer, value_columns_value_1);
+        }
     }
-    else if (styledValue_buf_selector == 8) {
-        styledValue_buf.selector = 8;
-        styledValue_buf.value8 = static_cast<Ark_LineHeightStyle>(LineHeightStyle_serializer::read(valueDeserializer));
+    const auto value_breakpoints = value.breakpoints;
+    Ark_Int32 value_breakpoints_type = INTEROP_RUNTIME_UNDEFINED;
+    value_breakpoints_type = runtimeType(value_breakpoints);
+    valueSerializer.writeInt8(value_breakpoints_type);
+    if ((value_breakpoints_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_breakpoints_value = value_breakpoints.value;
+        BreakPoints_serializer::write(valueSerializer, value_breakpoints_value);
     }
-    else if (styledValue_buf_selector == 9) {
-        styledValue_buf.selector = 9;
-        styledValue_buf.value9 = static_cast<Ark_UrlStyle>(UrlStyle_serializer::read(valueDeserializer));
+    const auto value_direction = value.direction;
+    Ark_Int32 value_direction_type = INTEROP_RUNTIME_UNDEFINED;
+    value_direction_type = runtimeType(value_direction);
+    valueSerializer.writeInt8(value_direction_type);
+    if ((value_direction_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_direction_value = value_direction.value;
+        valueSerializer.writeInt32(static_cast<Ark_GridRowDirection>(value_direction_value));
     }
-    else if (styledValue_buf_selector == 10) {
-        styledValue_buf.selector = 10;
-        styledValue_buf.value10 = static_cast<Ark_CustomSpan>(CustomSpan_serializer::read(valueDeserializer));
+}
+inline Ark_GridRowOptions GridRowOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_GridRowOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto gutter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Length_GutterOption gutter_buf = {};
+    gutter_buf.tag = gutter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((gutter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 gutter_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Length_GutterOption gutter_buf_ = {};
+        gutter_buf_.selector = gutter_buf__selector;
+        if (gutter_buf__selector == 0) {
+            gutter_buf_.selector = 0;
+            const Ark_Int8 gutter_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Length gutter_buf__u = {};
+            gutter_buf__u.selector = gutter_buf__u_selector;
+            if (gutter_buf__u_selector == 0) {
+                gutter_buf__u.selector = 0;
+                gutter_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (gutter_buf__u_selector == 1) {
+                gutter_buf__u.selector = 1;
+                gutter_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            else if (gutter_buf__u_selector == 2) {
+                gutter_buf__u.selector = 2;
+                gutter_buf__u.value2 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for gutter_buf__u has to be chosen through deserialisation.");
+            }
+            gutter_buf_.value0 = static_cast<Ark_Length>(gutter_buf__u);
+        }
+        else if (gutter_buf__selector == 1) {
+            gutter_buf_.selector = 1;
+            gutter_buf_.value1 = GutterOption_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for gutter_buf_ has to be chosen through deserialisation.");
+        }
+        gutter_buf.value = static_cast<Ark_Union_Length_GutterOption>(gutter_buf_);
     }
-    else if (styledValue_buf_selector == 11) {
-        styledValue_buf.selector = 11;
-        styledValue_buf.value11 = static_cast<Ark_UserDataSpan>(UserDataSpan_serializer::read(valueDeserializer));
+    value.gutter = gutter_buf;
+    const auto columns_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_GridRowColumnOption columns_buf = {};
+    columns_buf.tag = columns_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((columns_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 columns_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_GridRowColumnOption columns_buf_ = {};
+        columns_buf_.selector = columns_buf__selector;
+        if (columns_buf__selector == 0) {
+            columns_buf_.selector = 0;
+            columns_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (columns_buf__selector == 1) {
+            columns_buf_.selector = 1;
+            columns_buf_.value1 = GridRowColumnOption_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for columns_buf_ has to be chosen through deserialisation.");
+        }
+        columns_buf.value = static_cast<Ark_Union_Number_GridRowColumnOption>(columns_buf_);
     }
-    else if (styledValue_buf_selector == 12) {
-        styledValue_buf.selector = 12;
-        styledValue_buf.value12 = static_cast<Ark_BackgroundColorStyle>(BackgroundColorStyle_serializer::read(valueDeserializer));
+    value.columns = columns_buf;
+    const auto breakpoints_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BreakPoints breakpoints_buf = {};
+    breakpoints_buf.tag = breakpoints_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((breakpoints_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        breakpoints_buf.value = BreakPoints_serializer::read(valueDeserializer);
     }
-    else {
-        INTEROP_FATAL("One of the branches for styledValue_buf has to be chosen through deserialisation.");
+    value.breakpoints = breakpoints_buf;
+    const auto direction_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_GridRowDirection direction_buf = {};
+    direction_buf.tag = direction_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((direction_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        direction_buf.value = static_cast<Ark_GridRowDirection>(valueDeserializer.readInt32());
     }
-    value.styledValue = static_cast<Ark_StyledStringValue>(styledValue_buf);
+    value.direction = direction_buf;
     return value;
 }
-inline void AsymmetricTransitionOption_serializer::write(SerializerBase& buffer, Ark_AsymmetricTransitionOption value)
+inline void ImageAttachment_serializer::write(SerializerBase& buffer, Ark_ImageAttachment value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_appear = value.appear;
-    TransitionEffect_serializer::write(valueSerializer, value_appear);
-    const auto value_disappear = value.disappear;
-    TransitionEffect_serializer::write(valueSerializer, value_disappear);
+    valueSerializer.writePointer(value);
 }
-inline Ark_AsymmetricTransitionOption AsymmetricTransitionOption_serializer::read(DeserializerBase& buffer)
+inline Ark_ImageAttachment ImageAttachment_serializer::read(DeserializerBase& buffer)
 {
-    Ark_AsymmetricTransitionOption value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.appear = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
-    value.disappear = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
-    return value;
+    Ark_NativePointer ptr = valueDeserializer.readPointer();
+    return static_cast<Ark_ImageAttachment>(ptr);
 }
-inline void ContentCoverOptions_serializer::write(SerializerBase& buffer, Ark_ContentCoverOptions value)
+inline void ImageAttachmentInterface_serializer::write(SerializerBase& buffer, Ark_ImageAttachmentInterface value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value_value = value.value;
+    image_PixelMap_serializer::write(valueSerializer, value_value);
+    const auto value_size = value.size;
+    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
+    value_size_type = runtimeType(value_size);
+    valueSerializer.writeInt8(value_size_type);
+    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_size_value = value_size.value;
+        SizeOptions_serializer::write(valueSerializer, value_size_value);
+    }
+    const auto value_verticalAlign = value.verticalAlign;
+    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value_verticalAlign_type = runtimeType(value_verticalAlign);
+    valueSerializer.writeInt8(value_verticalAlign_type);
+    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_verticalAlign_value = value_verticalAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
+    }
+    const auto value_objectFit = value.objectFit;
+    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
+    value_objectFit_type = runtimeType(value_objectFit);
+    valueSerializer.writeInt8(value_objectFit_type);
+    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_objectFit_value = value_objectFit.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
+    }
+    const auto value_layoutStyle = value.layoutStyle;
+    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutStyle_type = runtimeType(value_layoutStyle);
+    valueSerializer.writeInt8(value_layoutStyle_type);
+    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutStyle_value = value_layoutStyle.value;
+        ImageAttachmentLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
+    }
+    const auto value_colorFilter = value.colorFilter;
+    Ark_Int32 value_colorFilter_type = INTEROP_RUNTIME_UNDEFINED;
+    value_colorFilter_type = runtimeType(value_colorFilter);
+    valueSerializer.writeInt8(value_colorFilter_type);
+    if ((value_colorFilter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_colorFilter_value = value_colorFilter.value;
+        Ark_Int32 value_colorFilter_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_colorFilter_value_type = value_colorFilter_value.selector;
+        if (value_colorFilter_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_colorFilter_value_0 = value_colorFilter_value.value0;
+            ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_0);
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_colorFilter_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
-        }
-        else if (value_backgroundColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
-        }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+            const auto value_colorFilter_value_1 = value_colorFilter_value.value1;
+            drawing_ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_1);
         }
     }
-    const auto value_onAppear = value.onAppear;
-    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onAppear_type = runtimeType(value_onAppear);
-    valueSerializer.writeInt8(value_onAppear_type);
-    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onAppear_value = value_onAppear.value;
-        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
-    }
-    const auto value_onDisappear = value.onDisappear;
-    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDisappear_type = runtimeType(value_onDisappear);
-    valueSerializer.writeInt8(value_onDisappear_type);
-    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDisappear_value = value_onDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
-    }
-    const auto value_onWillAppear = value.onWillAppear;
-    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillAppear_type = runtimeType(value_onWillAppear);
-    valueSerializer.writeInt8(value_onWillAppear_type);
-    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillAppear_value = value_onWillAppear.value;
-        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
-    }
-    const auto value_onWillDisappear = value.onWillDisappear;
-    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
-    valueSerializer.writeInt8(value_onWillDisappear_type);
-    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDisappear_value = value_onWillDisappear.value;
-        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
+}
+inline Ark_ImageAttachmentInterface ImageAttachmentInterface_serializer::read(DeserializerBase& buffer)
+{
+    Ark_ImageAttachmentInterface value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.value = static_cast<Ark_image_PixelMap>(image_PixelMap_serializer::read(valueDeserializer));
+    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SizeOptions size_buf = {};
+    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        size_buf.value = SizeOptions_serializer::read(valueDeserializer);
     }
-    const auto value_modalTransition = value.modalTransition;
-    Ark_Int32 value_modalTransition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_modalTransition_type = runtimeType(value_modalTransition);
-    valueSerializer.writeInt8(value_modalTransition_type);
-    if ((value_modalTransition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_modalTransition_value = value_modalTransition.value;
-        valueSerializer.writeInt32(static_cast<Ark_ModalTransition>(value_modalTransition_value));
+    value.size = size_buf;
+    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageSpanAlignment verticalAlign_buf = {};
+    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
     }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        valueSerializer.writeCallbackResource(value_onWillDismiss_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value.callSync));
+    value.verticalAlign = verticalAlign_buf;
+    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageFit objectFit_buf = {};
+    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
     }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    value.objectFit = objectFit_buf;
+    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageAttachmentLayoutStyle layoutStyle_buf = {};
+    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        layoutStyle_buf.value = ImageAttachmentLayoutStyle_serializer::read(valueDeserializer);
     }
-}
-inline Ark_ContentCoverOptions ContentCoverOptions_serializer::read(DeserializerBase& buffer)
-{
-    Ark_ContentCoverOptions value = {};
-    DeserializerBase& valueDeserializer = buffer;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.layoutStyle = layoutStyle_buf;
+    const auto colorFilter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ColorFilterType colorFilter_buf = {};
+    colorFilter_buf.tag = colorFilter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((colorFilter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 colorFilter_buf__selector = valueDeserializer.readInt8();
+        Ark_ColorFilterType colorFilter_buf_ = {};
+        colorFilter_buf_.selector = colorFilter_buf__selector;
+        if (colorFilter_buf__selector == 0) {
+            colorFilter_buf_.selector = 0;
+            colorFilter_buf_.value0 = static_cast<Ark_ColorFilter>(ColorFilter_serializer::read(valueDeserializer));
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (colorFilter_buf__selector == 1) {
+            colorFilter_buf_.selector = 1;
+            colorFilter_buf_.value1 = static_cast<Ark_drawing_ColorFilter>(drawing_ColorFilter_serializer::read(valueDeserializer));
         }
         else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for colorFilter_buf_ has to be chosen through deserialisation.");
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
+        colorFilter_buf.value = static_cast<Ark_ColorFilterType>(colorFilter_buf_);
     }
-    value.backgroundColor = backgroundColor_buf;
-    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onAppear_buf = {};
-    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    value.colorFilter = colorFilter_buf;
+    return value;
+}
+inline void NativeEmbedDataInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedDataInfo value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_status = value.status;
+    Ark_Int32 value_status_type = INTEROP_RUNTIME_UNDEFINED;
+    value_status_type = runtimeType(value_status);
+    valueSerializer.writeInt8(value_status_type);
+    if ((value_status_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_status_value = value_status.value;
+        valueSerializer.writeInt32(static_cast<Ark_NativeEmbedStatus>(value_status_value));
     }
-    value.onAppear = onAppear_buf;
-    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDisappear_buf = {};
-    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    const auto value_surfaceId = value.surfaceId;
+    Ark_Int32 value_surfaceId_type = INTEROP_RUNTIME_UNDEFINED;
+    value_surfaceId_type = runtimeType(value_surfaceId);
+    valueSerializer.writeInt8(value_surfaceId_type);
+    if ((value_surfaceId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_surfaceId_value = value_surfaceId.value;
+        valueSerializer.writeString(value_surfaceId_value);
     }
-    value.onDisappear = onDisappear_buf;
-    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillAppear_buf = {};
-    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    const auto value_embedId = value.embedId;
+    Ark_Int32 value_embedId_type = INTEROP_RUNTIME_UNDEFINED;
+    value_embedId_type = runtimeType(value_embedId);
+    valueSerializer.writeInt8(value_embedId_type);
+    if ((value_embedId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_embedId_value = value_embedId.value;
+        valueSerializer.writeString(value_embedId_value);
     }
-    value.onWillAppear = onWillAppear_buf;
-    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onWillDisappear_buf = {};
-    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto value_info = value.info;
+    Ark_Int32 value_info_type = INTEROP_RUNTIME_UNDEFINED;
+    value_info_type = runtimeType(value_info);
+    valueSerializer.writeInt8(value_info_type);
+    if ((value_info_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_info_value = value_info.value;
+        NativeEmbedInfo_serializer::write(valueSerializer, value_info_value);
+    }
+}
+inline Ark_NativeEmbedDataInfo NativeEmbedDataInfo_serializer::read(DeserializerBase& buffer)
+{
+    Ark_NativeEmbedDataInfo value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto status_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_NativeEmbedStatus status_buf = {};
+    status_buf.tag = status_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((status_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        status_buf.value = static_cast<Ark_NativeEmbedStatus>(valueDeserializer.readInt32());
     }
-    value.onWillDisappear = onWillDisappear_buf;
-    const auto modalTransition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ModalTransition modalTransition_buf = {};
-    modalTransition_buf.tag = modalTransition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((modalTransition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.status = status_buf;
+    const auto surfaceId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String surfaceId_buf = {};
+    surfaceId_buf.tag = surfaceId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((surfaceId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        modalTransition_buf.value = static_cast<Ark_ModalTransition>(valueDeserializer.readInt32());
+        surfaceId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.modalTransition = modalTransition_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_DismissContentCoverAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.surfaceId = surfaceId_buf;
+    const auto embedId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String embedId_buf = {};
+    embedId_buf.tag = embedId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((embedId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onWillDismiss_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissContentCoverAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissContentCoverAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissContentCoverAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissContentCoverAction_Void))))};
+        embedId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.embedId = embedId_buf;
+    const auto info_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_NativeEmbedInfo info_buf = {};
+    info_buf.tag = info_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((info_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+        info_buf.value = NativeEmbedInfo_serializer::read(valueDeserializer);
     }
-    value.transition = transition_buf;
+    value.info = info_buf;
     return value;
 }
-inline void ContextMenuAnimationOptions_serializer::write(SerializerBase& buffer, Ark_ContextMenuAnimationOptions value)
+inline void NativeEmbedTouchInfo_serializer::write(SerializerBase& buffer, Ark_NativeEmbedTouchInfo value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_scale = value.scale;
-    Ark_Int32 value_scale_type = INTEROP_RUNTIME_UNDEFINED;
-    value_scale_type = runtimeType(value_scale);
-    valueSerializer.writeInt8(value_scale_type);
-    if ((value_scale_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_scale_value = value_scale.value;
-        const auto value_scale_value_0 = value_scale_value.value0;
-        valueSerializer.writeNumber(value_scale_value_0);
-        const auto value_scale_value_1 = value_scale_value.value1;
-        valueSerializer.writeNumber(value_scale_value_1);
+    const auto value_embedId = value.embedId;
+    Ark_Int32 value_embedId_type = INTEROP_RUNTIME_UNDEFINED;
+    value_embedId_type = runtimeType(value_embedId);
+    valueSerializer.writeInt8(value_embedId_type);
+    if ((value_embedId_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_embedId_value = value_embedId.value;
+        valueSerializer.writeString(value_embedId_value);
     }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    const auto value_touchEvent = value.touchEvent;
+    Ark_Int32 value_touchEvent_type = INTEROP_RUNTIME_UNDEFINED;
+    value_touchEvent_type = runtimeType(value_touchEvent);
+    valueSerializer.writeInt8(value_touchEvent_type);
+    if ((value_touchEvent_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_touchEvent_value = value_touchEvent.value;
+        TouchEvent_serializer::write(valueSerializer, value_touchEvent_value);
     }
-    const auto value_hoverScale = value.hoverScale;
-    Ark_Int32 value_hoverScale_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hoverScale_type = runtimeType(value_hoverScale);
-    valueSerializer.writeInt8(value_hoverScale_type);
-    if ((value_hoverScale_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hoverScale_value = value_hoverScale.value;
-        const auto value_hoverScale_value_0 = value_hoverScale_value.value0;
-        valueSerializer.writeNumber(value_hoverScale_value_0);
-        const auto value_hoverScale_value_1 = value_hoverScale_value.value1;
-        valueSerializer.writeNumber(value_hoverScale_value_1);
+    const auto value_result = value.result;
+    Ark_Int32 value_result_type = INTEROP_RUNTIME_UNDEFINED;
+    value_result_type = runtimeType(value_result);
+    valueSerializer.writeInt8(value_result_type);
+    if ((value_result_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_result_value = value_result.value;
+        EventResult_serializer::write(valueSerializer, value_result_value);
     }
 }
-inline Ark_ContextMenuAnimationOptions ContextMenuAnimationOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_NativeEmbedTouchInfo NativeEmbedTouchInfo_serializer::read(DeserializerBase& buffer)
 {
-    Ark_ContextMenuAnimationOptions value = {};
+    Ark_NativeEmbedTouchInfo value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto scale_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_AnimationNumberRange scale_buf = {};
-    scale_buf.tag = scale_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((scale_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto embedId_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String embedId_buf = {};
+    embedId_buf.tag = embedId_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((embedId_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        Ark_AnimationNumberRange scale_buf_ = {};
-        scale_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        scale_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        scale_buf.value = scale_buf_;
+        embedId_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.scale = scale_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.embedId = embedId_buf;
+    const auto touchEvent_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TouchEvent touchEvent_buf = {};
+    touchEvent_buf.tag = touchEvent_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((touchEvent_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+        touchEvent_buf.value = static_cast<Ark_TouchEvent>(TouchEvent_serializer::read(valueDeserializer));
     }
-    value.transition = transition_buf;
-    const auto hoverScale_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_AnimationNumberRange hoverScale_buf = {};
-    hoverScale_buf.tag = hoverScale_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hoverScale_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.touchEvent = touchEvent_buf;
+    const auto result_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_EventResult result_buf = {};
+    result_buf.tag = result_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((result_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        Ark_AnimationNumberRange hoverScale_buf_ = {};
-        hoverScale_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        hoverScale_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        hoverScale_buf.value = hoverScale_buf_;
-    }
-    value.hoverScale = hoverScale_buf;
-    return value;
-}
-inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_ContextMenuOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
+        result_buf.value = static_cast<Ark_EventResult>(EventResult_serializer::read(valueDeserializer));
     }
+    value.result = result_buf;
+    return value;
+}
+inline void PopupOptions_serializer::write(SerializerBase& buffer, Ark_PopupOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_message = value.message;
+    valueSerializer.writeString(value_message);
     const auto value_placement = value.placement;
     Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
     value_placement_type = runtimeType(value_placement);
@@ -114891,13 +117257,31 @@ inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_Con
         const auto value_placement_value = value_placement.value;
         valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
     }
-    const auto value_enableArrow = value.enableArrow;
-    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableArrow_type = runtimeType(value_enableArrow);
-    valueSerializer.writeInt8(value_enableArrow_type);
-    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableArrow_value = value_enableArrow.value;
-        valueSerializer.writeBoolean(value_enableArrow_value);
+    const auto value_primaryButton = value.primaryButton;
+    Ark_Int32 value_primaryButton_type = INTEROP_RUNTIME_UNDEFINED;
+    value_primaryButton_type = runtimeType(value_primaryButton);
+    valueSerializer.writeInt8(value_primaryButton_type);
+    if ((value_primaryButton_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_primaryButton_value = value_primaryButton.value;
+        PopupButton_serializer::write(valueSerializer, value_primaryButton_value);
+    }
+    const auto value_secondaryButton = value.secondaryButton;
+    Ark_Int32 value_secondaryButton_type = INTEROP_RUNTIME_UNDEFINED;
+    value_secondaryButton_type = runtimeType(value_secondaryButton);
+    valueSerializer.writeInt8(value_secondaryButton_type);
+    if ((value_secondaryButton_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_secondaryButton_value = value_secondaryButton.value;
+        PopupButton_serializer::write(valueSerializer, value_secondaryButton_value);
+    }
+    const auto value_onStateChange = value.onStateChange;
+    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onStateChange_type = runtimeType(value_onStateChange);
+    valueSerializer.writeInt8(value_onStateChange_type);
+    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onStateChange_value = value_onStateChange.value;
+        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
     }
     const auto value_arrowOffset = value.arrowOffset;
     Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
@@ -114923,190 +117307,239 @@ inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_Con
             Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
         }
     }
-    const auto value_preview = value.preview;
-    Ark_Int32 value_preview_type = INTEROP_RUNTIME_UNDEFINED;
-    value_preview_type = runtimeType(value_preview);
-    valueSerializer.writeInt8(value_preview_type);
-    if ((value_preview_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_preview_value = value_preview.value;
-        Ark_Int32 value_preview_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_preview_value_type = value_preview_value.selector;
-        if (value_preview_value_type == 0) {
+    const auto value_showInSubWindow = value.showInSubWindow;
+    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
+    valueSerializer.writeInt8(value_showInSubWindow_type);
+    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_showInSubWindow_value = value_showInSubWindow.value;
+        valueSerializer.writeBoolean(value_showInSubWindow_value);
+    }
+    const auto value_mask = value.mask;
+    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
+    value_mask_type = runtimeType(value_mask);
+    valueSerializer.writeInt8(value_mask_type);
+    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_mask_value = value_mask.value;
+        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_mask_value_type = value_mask_value.selector;
+        if (value_mask_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_preview_value_0 = value_preview_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_MenuPreviewMode>(value_preview_value_0));
+            const auto value_mask_value_0 = value_mask_value.value0;
+            valueSerializer.writeBoolean(value_mask_value_0);
         }
-        else if (value_preview_value_type == 1) {
+        else if (value_mask_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_preview_value_1 = value_preview_value.value1;
-            valueSerializer.writeCallbackResource(value_preview_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.callSync));
+            const auto value_mask_value_1 = value_mask_value.value1;
+            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
         }
     }
-    const auto value_previewBorderRadius = value.previewBorderRadius;
-    Ark_Int32 value_previewBorderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_previewBorderRadius_type = runtimeType(value_previewBorderRadius);
-    valueSerializer.writeInt8(value_previewBorderRadius_type);
-    if ((value_previewBorderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_previewBorderRadius_value = value_previewBorderRadius.value;
-        Ark_Int32 value_previewBorderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_previewBorderRadius_value_type = value_previewBorderRadius_value.selector;
-        if ((value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0)) {
+    const auto value_messageOptions = value.messageOptions;
+    Ark_Int32 value_messageOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_messageOptions_type = runtimeType(value_messageOptions);
+    valueSerializer.writeInt8(value_messageOptions_type);
+    if ((value_messageOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_messageOptions_value = value_messageOptions.value;
+        PopupMessageOptions_serializer::write(valueSerializer, value_messageOptions_value);
+    }
+    const auto value_targetSpace = value.targetSpace;
+    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
+    value_targetSpace_type = runtimeType(value_targetSpace);
+    valueSerializer.writeInt8(value_targetSpace_type);
+    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_targetSpace_value = value_targetSpace.value;
+        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_targetSpace_value_type = value_targetSpace_value.selector;
+        if (value_targetSpace_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_previewBorderRadius_value_0 = value_previewBorderRadius_value.value0;
-            Ark_Int32 value_previewBorderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_previewBorderRadius_value_0_type = value_previewBorderRadius_value_0.selector;
-            if (value_previewBorderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_previewBorderRadius_value_0_0 = value_previewBorderRadius_value_0.value0;
-                valueSerializer.writeString(value_previewBorderRadius_value_0_0);
-            }
-            else if (value_previewBorderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_previewBorderRadius_value_0_1 = value_previewBorderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_previewBorderRadius_value_0_1);
-            }
-            else if (value_previewBorderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_previewBorderRadius_value_0_2 = value_previewBorderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_previewBorderRadius_value_0_2);
-            }
+            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
+            valueSerializer.writeString(value_targetSpace_value_0);
         }
-        else if (value_previewBorderRadius_value_type == 1) {
+        else if (value_targetSpace_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_previewBorderRadius_value_1 = value_previewBorderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_1);
+            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
+            valueSerializer.writeNumber(value_targetSpace_value_1);
         }
-        else if (value_previewBorderRadius_value_type == 2) {
+        else if (value_targetSpace_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_previewBorderRadius_value_2 = value_previewBorderRadius_value.value2;
-            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_2);
+            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
+            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
         }
     }
-    const auto value_borderRadius = value.borderRadius;
-    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderRadius_type = runtimeType(value_borderRadius);
-    valueSerializer.writeInt8(value_borderRadius_type);
-    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderRadius_value = value_borderRadius.value;
-        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderRadius_value_type = value_borderRadius_value.selector;
-        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
+    const auto value_enableArrow = value.enableArrow;
+    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableArrow_type = runtimeType(value_enableArrow);
+    valueSerializer.writeInt8(value_enableArrow_type);
+    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableArrow_value = value_enableArrow.value;
+        valueSerializer.writeBoolean(value_enableArrow_value);
+    }
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        Position_serializer::write(valueSerializer, value_offset_value);
+    }
+    const auto value_popupColor = value.popupColor;
+    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_popupColor_type = runtimeType(value_popupColor);
+    valueSerializer.writeInt8(value_popupColor_type);
+    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_popupColor_value = value_popupColor.value;
+        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_popupColor_value_type = value_popupColor_value.selector;
+        if (value_popupColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
-            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
-            if (value_borderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
-                valueSerializer.writeString(value_borderRadius_value_0_0);
-            }
-            else if (value_borderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_borderRadius_value_0_1);
-            }
-            else if (value_borderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
-            }
+            const auto value_popupColor_value_0 = value_popupColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
         }
-        else if (value_borderRadius_value_type == 1) {
+        else if (value_popupColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
+            const auto value_popupColor_value_1 = value_popupColor_value.value1;
+            valueSerializer.writeString(value_popupColor_value_1);
         }
-        else if (value_borderRadius_value_type == 2) {
+        else if (value_popupColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_borderRadius_value_2 = value_borderRadius_value.value2;
-            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_2);
+            const auto value_popupColor_value_2 = value_popupColor_value.value2;
+            Resource_serializer::write(valueSerializer, value_popupColor_value_2);
+        }
+        else if (value_popupColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_popupColor_value_3 = value_popupColor_value.value3;
+            valueSerializer.writeNumber(value_popupColor_value_3);
         }
     }
-    const auto value_onAppear = value.onAppear;
-    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onAppear_type = runtimeType(value_onAppear);
-    valueSerializer.writeInt8(value_onAppear_type);
-    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onAppear_value = value_onAppear.value;
-        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
-    }
-    const auto value_onDisappear = value.onDisappear;
-    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDisappear_type = runtimeType(value_onDisappear);
-    valueSerializer.writeInt8(value_onDisappear_type);
-    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDisappear_value = value_onDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
+    const auto value_autoCancel = value.autoCancel;
+    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_autoCancel_type = runtimeType(value_autoCancel);
+    valueSerializer.writeInt8(value_autoCancel_type);
+    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_autoCancel_value = value_autoCancel.value;
+        valueSerializer.writeBoolean(value_autoCancel_value);
     }
-    const auto value_aboutToAppear = value.aboutToAppear;
-    Ark_Int32 value_aboutToAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_aboutToAppear_type = runtimeType(value_aboutToAppear);
-    valueSerializer.writeInt8(value_aboutToAppear_type);
-    if ((value_aboutToAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_aboutToAppear_value = value_aboutToAppear.value;
-        valueSerializer.writeCallbackResource(value_aboutToAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.callSync));
+    const auto value_width = value.width;
+    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
+    value_width_type = runtimeType(value_width);
+    valueSerializer.writeInt8(value_width_type);
+    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_width_value = value_width.value;
+        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_width_value_type = value_width_value.selector;
+        if (value_width_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_width_value_0 = value_width_value.value0;
+            valueSerializer.writeString(value_width_value_0);
+        }
+        else if (value_width_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_width_value_1 = value_width_value.value1;
+            valueSerializer.writeNumber(value_width_value_1);
+        }
+        else if (value_width_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_width_value_2 = value_width_value.value2;
+            Resource_serializer::write(valueSerializer, value_width_value_2);
+        }
     }
-    const auto value_aboutToDisappear = value.aboutToDisappear;
-    Ark_Int32 value_aboutToDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_aboutToDisappear_type = runtimeType(value_aboutToDisappear);
-    valueSerializer.writeInt8(value_aboutToDisappear_type);
-    if ((value_aboutToDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_aboutToDisappear_value = value_aboutToDisappear.value;
-        valueSerializer.writeCallbackResource(value_aboutToDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.callSync));
+    const auto value_arrowPointPosition = value.arrowPointPosition;
+    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
+    valueSerializer.writeInt8(value_arrowPointPosition_type);
+    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
+        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
     }
-    const auto value_layoutRegionMargin = value.layoutRegionMargin;
-    Ark_Int32 value_layoutRegionMargin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin);
-    valueSerializer.writeInt8(value_layoutRegionMargin_type);
-    if ((value_layoutRegionMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutRegionMargin_value = value_layoutRegionMargin.value;
-        Padding_serializer::write(valueSerializer, value_layoutRegionMargin_value);
+    const auto value_arrowWidth = value.arrowWidth;
+    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowWidth_type = runtimeType(value_arrowWidth);
+    valueSerializer.writeInt8(value_arrowWidth_type);
+    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowWidth_value = value_arrowWidth.value;
+        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowWidth_value_type = value_arrowWidth_value.selector;
+        if (value_arrowWidth_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
+            valueSerializer.writeString(value_arrowWidth_value_0);
+        }
+        else if (value_arrowWidth_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
+            valueSerializer.writeNumber(value_arrowWidth_value_1);
+        }
+        else if (value_arrowWidth_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
+        }
     }
-    const auto value_previewAnimationOptions = value.previewAnimationOptions;
-    Ark_Int32 value_previewAnimationOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions);
-    valueSerializer.writeInt8(value_previewAnimationOptions_type);
-    if ((value_previewAnimationOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_previewAnimationOptions_value = value_previewAnimationOptions.value;
-        ContextMenuAnimationOptions_serializer::write(valueSerializer, value_previewAnimationOptions_value);
+    const auto value_arrowHeight = value.arrowHeight;
+    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_arrowHeight_type = runtimeType(value_arrowHeight);
+    valueSerializer.writeInt8(value_arrowHeight_type);
+    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_arrowHeight_value = value_arrowHeight.value;
+        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_arrowHeight_value_type = value_arrowHeight_value.selector;
+        if (value_arrowHeight_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
+            valueSerializer.writeString(value_arrowHeight_value_0);
+        }
+        else if (value_arrowHeight_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
+            valueSerializer.writeNumber(value_arrowHeight_value_1);
+        }
+        else if (value_arrowHeight_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
+            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
+        }
     }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
+    const auto value_radius = value.radius;
+    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
+    value_radius_type = runtimeType(value_radius);
+    valueSerializer.writeInt8(value_radius_type);
+    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_radius_value = value_radius.value;
+        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_radius_value_type = value_radius_value.selector;
+        if (value_radius_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
+            const auto value_radius_value_0 = value_radius_value.value0;
+            valueSerializer.writeString(value_radius_value_0);
         }
-        else if (value_backgroundColor_value_type == 1) {
+        else if (value_radius_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
+            const auto value_radius_value_1 = value_radius_value.value1;
+            valueSerializer.writeNumber(value_radius_value_1);
         }
-        else if (value_backgroundColor_value_type == 2) {
+        else if (value_radius_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
+            const auto value_radius_value_2 = value_radius_value.value2;
+            Resource_serializer::write(valueSerializer, value_radius_value_2);
         }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
+    }
+    const auto value_shadow = value.shadow;
+    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_shadow_type = runtimeType(value_shadow);
+    valueSerializer.writeInt8(value_shadow_type);
+    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_shadow_value = value_shadow.value;
+        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_shadow_value_type = value_shadow_value.selector;
+        if (value_shadow_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_shadow_value_0 = value_shadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+        }
+        else if (value_shadow_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_shadow_value_1 = value_shadow_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
     }
     const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
@@ -115117,22 +117550,6 @@ inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_Con
         const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
         valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
     }
-    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
-    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
-    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
-    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
-        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
-    }
-    const auto value_backgroundEffect = value.backgroundEffect;
-    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
-    valueSerializer.writeInt8(value_backgroundEffect_type);
-    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundEffect_value = value_backgroundEffect.value;
-        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
-    }
     const auto value_transition = value.transition;
     Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
     value_transition_type = runtimeType(value_transition);
@@ -115141,6 +117558,27 @@ inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_Con
         const auto value_transition_value = value_transition.value;
         TransitionEffect_serializer::write(valueSerializer, value_transition_value);
     }
+    const auto value_onWillDismiss = value.onWillDismiss;
+    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
+    valueSerializer.writeInt8(value_onWillDismiss_type);
+    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDismiss_value = value_onWillDismiss.value;
+        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
+        if (value_onWillDismiss_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
+            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
+        }
+        else if (value_onWillDismiss_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
+            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
+            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
+        }
+    }
     const auto value_enableHoverMode = value.enableHoverMode;
     Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
     value_enableHoverMode_type = runtimeType(value_enableHoverMode);
@@ -115149,102 +117587,28 @@ inline void ContextMenuOptions_serializer::write(SerializerBase& buffer, Ark_Con
         const auto value_enableHoverMode_value = value_enableHoverMode.value;
         valueSerializer.writeBoolean(value_enableHoverMode_value);
     }
-    const auto value_outlineColor = value.outlineColor;
-    Ark_Int32 value_outlineColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_outlineColor_type = runtimeType(value_outlineColor);
-    valueSerializer.writeInt8(value_outlineColor_type);
-    if ((value_outlineColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_outlineColor_value = value_outlineColor.value;
-        Ark_Int32 value_outlineColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_outlineColor_value_type = value_outlineColor_value.selector;
-        if ((value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_outlineColor_value_0 = value_outlineColor_value.value0;
-            Ark_Int32 value_outlineColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_outlineColor_value_0_type = value_outlineColor_value_0.selector;
-            if (value_outlineColor_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_outlineColor_value_0_0 = value_outlineColor_value_0.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_outlineColor_value_0_0));
-            }
-            else if (value_outlineColor_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_outlineColor_value_0_1 = value_outlineColor_value_0.value1;
-                valueSerializer.writeNumber(value_outlineColor_value_0_1);
-            }
-            else if (value_outlineColor_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_outlineColor_value_0_2 = value_outlineColor_value_0.value2;
-                valueSerializer.writeString(value_outlineColor_value_0_2);
-            }
-            else if (value_outlineColor_value_0_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_outlineColor_value_0_3 = value_outlineColor_value_0.value3;
-                Resource_serializer::write(valueSerializer, value_outlineColor_value_0_3);
-            }
-        }
-        else if (value_outlineColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_outlineColor_value_1 = value_outlineColor_value.value1;
-            EdgeColors_serializer::write(valueSerializer, value_outlineColor_value_1);
-        }
-    }
-    const auto value_outlineWidth = value.outlineWidth;
-    Ark_Int32 value_outlineWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_outlineWidth_type = runtimeType(value_outlineWidth);
-    valueSerializer.writeInt8(value_outlineWidth_type);
-    if ((value_outlineWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_outlineWidth_value = value_outlineWidth.value;
-        Ark_Int32 value_outlineWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_outlineWidth_value_type = value_outlineWidth_value.selector;
-        if ((value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_outlineWidth_value_0 = value_outlineWidth_value.value0;
-            Ark_Int32 value_outlineWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_outlineWidth_value_0_type = value_outlineWidth_value_0.selector;
-            if (value_outlineWidth_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_outlineWidth_value_0_0 = value_outlineWidth_value_0.value0;
-                valueSerializer.writeString(value_outlineWidth_value_0_0);
-            }
-            else if (value_outlineWidth_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_outlineWidth_value_0_1 = value_outlineWidth_value_0.value1;
-                valueSerializer.writeNumber(value_outlineWidth_value_0_1);
-            }
-            else if (value_outlineWidth_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_outlineWidth_value_0_2 = value_outlineWidth_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_outlineWidth_value_0_2);
-            }
-        }
-        else if (value_outlineWidth_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_outlineWidth_value_1 = value_outlineWidth_value.value1;
-            EdgeOutlineWidths_serializer::write(valueSerializer, value_outlineWidth_value_1);
-        }
+    const auto value_followTransformOfTarget = value.followTransformOfTarget;
+    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
+    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
+    valueSerializer.writeInt8(value_followTransformOfTarget_type);
+    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
+        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
     }
-    const auto value_hapticFeedbackMode = value.hapticFeedbackMode;
-    Ark_Int32 value_hapticFeedbackMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode);
-    valueSerializer.writeInt8(value_hapticFeedbackMode_type);
-    if ((value_hapticFeedbackMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hapticFeedbackMode_value = value_hapticFeedbackMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_HapticFeedbackMode>(value_hapticFeedbackMode_value));
+    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
+    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
+    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
+    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
     }
 }
-inline Ark_ContextMenuOptions ContextMenuOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_PopupOptions PopupOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_ContextMenuOptions value = {};
+    Ark_PopupOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
-    }
-    value.offset = offset_buf;
+    value.message = static_cast<Ark_String>(valueDeserializer.readString());
     const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Placement placement_buf = {};
     placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -115253,14 +117617,30 @@ inline Ark_ContextMenuOptions ContextMenuOptions_serializer::read(DeserializerBa
         placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
     }
     value.placement = placement_buf;
-    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableArrow_buf = {};
-    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto primaryButton_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupButton primaryButton_buf = {};
+    primaryButton_buf.tag = primaryButton_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((primaryButton_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableArrow_buf.value = valueDeserializer.readBoolean();
+        primaryButton_buf.value = PopupButton_serializer::read(valueDeserializer);
     }
-    value.enableArrow = enableArrow_buf;
+    value.primaryButton = primaryButton_buf;
+    const auto secondaryButton_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupButton secondaryButton_buf = {};
+    secondaryButton_buf.tag = secondaryButton_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((secondaryButton_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        secondaryButton_buf.value = PopupButton_serializer::read(valueDeserializer);
+    }
+    value.secondaryButton = secondaryButton_buf;
+    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupStateChangeCallback onStateChange_buf = {};
+    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
+    }
+    value.onStateChange = onStateChange_buf;
     const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
     Opt_Length arrowOffset_buf = {};
     arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
@@ -115287,2083 +117667,2214 @@ inline Ark_ContextMenuOptions ContextMenuOptions_serializer::read(DeserializerBa
         arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
     }
     value.arrowOffset = arrowOffset_buf;
-    const auto preview_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_MenuPreviewMode_CustomBuilder preview_buf = {};
-    preview_buf.tag = preview_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((preview_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean showInSubWindow_buf = {};
+    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 preview_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_MenuPreviewMode_CustomBuilder preview_buf_ = {};
-        preview_buf_.selector = preview_buf__selector;
-        if (preview_buf__selector == 0) {
-            preview_buf_.selector = 0;
-            preview_buf_.value0 = static_cast<Ark_MenuPreviewMode>(valueDeserializer.readInt32());
+        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+    }
+    value.showInSubWindow = showInSubWindow_buf;
+    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_PopupMaskType mask_buf = {};
+    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
+        mask_buf_.selector = mask_buf__selector;
+        if (mask_buf__selector == 0) {
+            mask_buf_.selector = 0;
+            mask_buf_.value0 = valueDeserializer.readBoolean();
         }
-        else if (preview_buf__selector == 1) {
-            preview_buf_.selector = 1;
-            preview_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
+        else if (mask_buf__selector == 1) {
+            mask_buf_.selector = 1;
+            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for preview_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
         }
-        preview_buf.value = static_cast<Ark_Union_MenuPreviewMode_CustomBuilder>(preview_buf_);
+        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
     }
-    value.preview = preview_buf;
-    const auto previewBorderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BorderRadiusType previewBorderRadius_buf = {};
-    previewBorderRadius_buf.tag = previewBorderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((previewBorderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.mask = mask_buf;
+    const auto messageOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PopupMessageOptions messageOptions_buf = {};
+    messageOptions_buf.tag = messageOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((messageOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 previewBorderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_BorderRadiusType previewBorderRadius_buf_ = {};
-        previewBorderRadius_buf_.selector = previewBorderRadius_buf__selector;
-        if (previewBorderRadius_buf__selector == 0) {
-            previewBorderRadius_buf_.selector = 0;
-            const Ark_Int8 previewBorderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length previewBorderRadius_buf__u = {};
-            previewBorderRadius_buf__u.selector = previewBorderRadius_buf__u_selector;
-            if (previewBorderRadius_buf__u_selector == 0) {
-                previewBorderRadius_buf__u.selector = 0;
-                previewBorderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (previewBorderRadius_buf__u_selector == 1) {
-                previewBorderRadius_buf__u.selector = 1;
-                previewBorderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (previewBorderRadius_buf__u_selector == 2) {
-                previewBorderRadius_buf__u.selector = 2;
-                previewBorderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            previewBorderRadius_buf_.value0 = static_cast<Ark_Length>(previewBorderRadius_buf__u);
+        messageOptions_buf.value = PopupMessageOptions_serializer::read(valueDeserializer);
+    }
+    value.messageOptions = messageOptions_buf;
+    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Length targetSpace_buf = {};
+    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
+        Ark_Length targetSpace_buf_ = {};
+        targetSpace_buf_.selector = targetSpace_buf__selector;
+        if (targetSpace_buf__selector == 0) {
+            targetSpace_buf_.selector = 0;
+            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (previewBorderRadius_buf__selector == 1) {
-            previewBorderRadius_buf_.selector = 1;
-            previewBorderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+        else if (targetSpace_buf__selector == 1) {
+            targetSpace_buf_.selector = 1;
+            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (previewBorderRadius_buf__selector == 2) {
-            previewBorderRadius_buf_.selector = 2;
-            previewBorderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
+        else if (targetSpace_buf__selector == 2) {
+            targetSpace_buf_.selector = 2;
+            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
         }
-        previewBorderRadius_buf.value = static_cast<Ark_BorderRadiusType>(previewBorderRadius_buf_);
+        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
     }
-    value.previewBorderRadius = previewBorderRadius_buf;
-    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf = {};
-    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.targetSpace = targetSpace_buf;
+    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableArrow_buf = {};
+    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf_ = {};
-        borderRadius_buf_.selector = borderRadius_buf__selector;
-        if (borderRadius_buf__selector == 0) {
-            borderRadius_buf_.selector = 0;
-            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length borderRadius_buf__u = {};
-            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
-            if (borderRadius_buf__u_selector == 0) {
-                borderRadius_buf__u.selector = 0;
-                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderRadius_buf__u_selector == 1) {
-                borderRadius_buf__u.selector = 1;
-                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderRadius_buf__u_selector == 2) {
-                borderRadius_buf__u.selector = 2;
-                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
+        enableArrow_buf.value = valueDeserializer.readBoolean();
+    }
+    value.enableArrow = enableArrow_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Position offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offset_buf.value = Position_serializer::read(valueDeserializer);
+    }
+    value.offset = offset_buf;
+    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Color_String_Resource_Number popupColor_buf = {};
+    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Color_String_Resource_Number popupColor_buf_ = {};
+        popupColor_buf_.selector = popupColor_buf__selector;
+        if (popupColor_buf__selector == 0) {
+            popupColor_buf_.selector = 0;
+            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+        }
+        else if (popupColor_buf__selector == 1) {
+            popupColor_buf_.selector = 1;
+            popupColor_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (popupColor_buf__selector == 2) {
+            popupColor_buf_.selector = 2;
+            popupColor_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else if (popupColor_buf__selector == 3) {
+            popupColor_buf_.selector = 3;
+            popupColor_buf_.value3 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
+        }
+        popupColor_buf.value = static_cast<Ark_Union_Color_String_Resource_Number>(popupColor_buf_);
+    }
+    value.popupColor = popupColor_buf;
+    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean autoCancel_buf = {};
+    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        autoCancel_buf.value = valueDeserializer.readBoolean();
+    }
+    value.autoCancel = autoCancel_buf;
+    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension width_buf = {};
+    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension width_buf_ = {};
+        width_buf_.selector = width_buf__selector;
+        if (width_buf__selector == 0) {
+            width_buf_.selector = 0;
+            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (width_buf__selector == 1) {
+            width_buf_.selector = 1;
+            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (width_buf__selector == 2) {
+            width_buf_.selector = 2;
+            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+        }
+        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
+    }
+    value.width = width_buf;
+    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ArrowPointPosition arrowPointPosition_buf = {};
+    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
+    }
+    value.arrowPointPosition = arrowPointPosition_buf;
+    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowWidth_buf = {};
+    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowWidth_buf_ = {};
+        arrowWidth_buf_.selector = arrowWidth_buf__selector;
+        if (arrowWidth_buf__selector == 0) {
+            arrowWidth_buf_.selector = 0;
+            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowWidth_buf__selector == 1) {
+            arrowWidth_buf_.selector = 1;
+            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowWidth_buf__selector == 2) {
+            arrowWidth_buf_.selector = 2;
+            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
+        }
+        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
+    }
+    value.arrowWidth = arrowWidth_buf;
+    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension arrowHeight_buf = {};
+    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension arrowHeight_buf_ = {};
+        arrowHeight_buf_.selector = arrowHeight_buf__selector;
+        if (arrowHeight_buf__selector == 0) {
+            arrowHeight_buf_.selector = 0;
+            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (arrowHeight_buf__selector == 1) {
+            arrowHeight_buf_.selector = 1;
+            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (arrowHeight_buf__selector == 2) {
+            arrowHeight_buf_.selector = 2;
+            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
+        }
+        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
+    }
+    value.arrowHeight = arrowHeight_buf;
+    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Dimension radius_buf = {};
+    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
+        Ark_Dimension radius_buf_ = {};
+        radius_buf_.selector = radius_buf__selector;
+        if (radius_buf__selector == 0) {
+            radius_buf_.selector = 0;
+            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (radius_buf__selector == 1) {
+            radius_buf_.selector = 1;
+            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (radius_buf__selector == 2) {
+            radius_buf_.selector = 2;
+            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        }
+        else {
+            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+        }
+        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
+    }
+    value.radius = radius_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        }
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        }
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+        }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+    }
+    value.shadow = shadow_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+    }
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TransitionEffect transition_buf = {};
+    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    }
+    value.transition = transition_buf;
+    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
+    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
+        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
+        if (onWillDismiss_buf__selector == 0) {
+            onWillDismiss_buf_.selector = 0;
+            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
+        }
+        else if (onWillDismiss_buf__selector == 1) {
+            onWillDismiss_buf_.selector = 1;
+            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
+        }
+        else {
+            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
+        }
+        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
+    }
+    value.onWillDismiss = onWillDismiss_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+    }
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean followTransformOfTarget_buf = {};
+    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
+    }
+    value.followTransformOfTarget = followTransformOfTarget_buf;
+    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
+    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
+    }
+    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    return value;
+}
+inline void ResourceImageAttachmentOptions_serializer::write(SerializerBase& buffer, Ark_ResourceImageAttachmentOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_resourceValue = value.resourceValue;
+    Ark_Int32 value_resourceValue_type = INTEROP_RUNTIME_UNDEFINED;
+    value_resourceValue_type = runtimeType(value_resourceValue);
+    valueSerializer.writeInt8(value_resourceValue_type);
+    if ((value_resourceValue_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_resourceValue_value = value_resourceValue.value;
+        Ark_Int32 value_resourceValue_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_resourceValue_value_type = value_resourceValue_value.selector;
+        if (value_resourceValue_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_resourceValue_value_0 = value_resourceValue_value.value0;
+            valueSerializer.writeString(value_resourceValue_value_0);
+        }
+        else if (value_resourceValue_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_resourceValue_value_1 = value_resourceValue_value.value1;
+            Resource_serializer::write(valueSerializer, value_resourceValue_value_1);
+        }
+    }
+    const auto value_size = value.size;
+    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
+    value_size_type = runtimeType(value_size);
+    valueSerializer.writeInt8(value_size_type);
+    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_size_value = value_size.value;
+        SizeOptions_serializer::write(valueSerializer, value_size_value);
+    }
+    const auto value_verticalAlign = value.verticalAlign;
+    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value_verticalAlign_type = runtimeType(value_verticalAlign);
+    valueSerializer.writeInt8(value_verticalAlign_type);
+    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_verticalAlign_value = value_verticalAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
+    }
+    const auto value_objectFit = value.objectFit;
+    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
+    value_objectFit_type = runtimeType(value_objectFit);
+    valueSerializer.writeInt8(value_objectFit_type);
+    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_objectFit_value = value_objectFit.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
+    }
+    const auto value_layoutStyle = value.layoutStyle;
+    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutStyle_type = runtimeType(value_layoutStyle);
+    valueSerializer.writeInt8(value_layoutStyle_type);
+    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutStyle_value = value_layoutStyle.value;
+        ImageAttachmentLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
+    }
+    const auto value_colorFilter = value.colorFilter;
+    Ark_Int32 value_colorFilter_type = INTEROP_RUNTIME_UNDEFINED;
+    value_colorFilter_type = runtimeType(value_colorFilter);
+    valueSerializer.writeInt8(value_colorFilter_type);
+    if ((value_colorFilter_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_colorFilter_value = value_colorFilter.value;
+        Ark_Int32 value_colorFilter_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_colorFilter_value_type = value_colorFilter_value.selector;
+        if (value_colorFilter_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_colorFilter_value_0 = value_colorFilter_value.value0;
+            ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_0);
+        }
+        else if (value_colorFilter_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_colorFilter_value_1 = value_colorFilter_value.value1;
+            drawing_ColorFilter_serializer::write(valueSerializer, value_colorFilter_value_1);
         }
-        else if (borderRadius_buf__selector == 1) {
-            borderRadius_buf_.selector = 1;
-            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
+    }
+    const auto value_syncLoad = value.syncLoad;
+    Ark_Int32 value_syncLoad_type = INTEROP_RUNTIME_UNDEFINED;
+    value_syncLoad_type = runtimeType(value_syncLoad);
+    valueSerializer.writeInt8(value_syncLoad_type);
+    if ((value_syncLoad_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_syncLoad_value = value_syncLoad.value;
+        valueSerializer.writeBoolean(value_syncLoad_value);
+    }
+}
+inline Ark_ResourceImageAttachmentOptions ResourceImageAttachmentOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_ResourceImageAttachmentOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto resourceValue_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceStr resourceValue_buf = {};
+    resourceValue_buf.tag = resourceValue_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((resourceValue_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 resourceValue_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceStr resourceValue_buf_ = {};
+        resourceValue_buf_.selector = resourceValue_buf__selector;
+        if (resourceValue_buf__selector == 0) {
+            resourceValue_buf_.selector = 0;
+            resourceValue_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (borderRadius_buf__selector == 2) {
-            borderRadius_buf_.selector = 2;
-            borderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
+        else if (resourceValue_buf__selector == 1) {
+            resourceValue_buf_.selector = 1;
+            resourceValue_buf_.value1 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for resourceValue_buf_ has to be chosen through deserialisation.");
         }
-        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses>(borderRadius_buf_);
+        resourceValue_buf.value = static_cast<Ark_ResourceStr>(resourceValue_buf_);
     }
-    value.borderRadius = borderRadius_buf;
-    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onAppear_buf = {};
-    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.resourceValue = resourceValue_buf;
+    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SizeOptions size_buf = {};
+    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        size_buf.value = SizeOptions_serializer::read(valueDeserializer);
     }
-    value.onAppear = onAppear_buf;
-    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDisappear_buf = {};
-    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.size = size_buf;
+    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageSpanAlignment verticalAlign_buf = {};
+    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
     }
-    value.onDisappear = onDisappear_buf;
-    const auto aboutToAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void aboutToAppear_buf = {};
-    aboutToAppear_buf.tag = aboutToAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((aboutToAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.verticalAlign = verticalAlign_buf;
+    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageFit objectFit_buf = {};
+    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        aboutToAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
     }
-    value.aboutToAppear = aboutToAppear_buf;
-    const auto aboutToDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void aboutToDisappear_buf = {};
-    aboutToDisappear_buf.tag = aboutToDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((aboutToDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.objectFit = objectFit_buf;
+    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageAttachmentLayoutStyle layoutStyle_buf = {};
+    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        aboutToDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+        layoutStyle_buf.value = ImageAttachmentLayoutStyle_serializer::read(valueDeserializer);
     }
-    value.aboutToDisappear = aboutToDisappear_buf;
-    const auto layoutRegionMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Padding layoutRegionMargin_buf = {};
-    layoutRegionMargin_buf.tag = layoutRegionMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutRegionMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.layoutStyle = layoutStyle_buf;
+    const auto colorFilter_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ColorFilterType colorFilter_buf = {};
+    colorFilter_buf.tag = colorFilter_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((colorFilter_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        layoutRegionMargin_buf.value = Padding_serializer::read(valueDeserializer);
+        const Ark_Int8 colorFilter_buf__selector = valueDeserializer.readInt8();
+        Ark_ColorFilterType colorFilter_buf_ = {};
+        colorFilter_buf_.selector = colorFilter_buf__selector;
+        if (colorFilter_buf__selector == 0) {
+            colorFilter_buf_.selector = 0;
+            colorFilter_buf_.value0 = static_cast<Ark_ColorFilter>(ColorFilter_serializer::read(valueDeserializer));
+        }
+        else if (colorFilter_buf__selector == 1) {
+            colorFilter_buf_.selector = 1;
+            colorFilter_buf_.value1 = static_cast<Ark_drawing_ColorFilter>(drawing_ColorFilter_serializer::read(valueDeserializer));
+        }
+        else {
+            INTEROP_FATAL("One of the branches for colorFilter_buf_ has to be chosen through deserialisation.");
+        }
+        colorFilter_buf.value = static_cast<Ark_ColorFilterType>(colorFilter_buf_);
     }
-    value.layoutRegionMargin = layoutRegionMargin_buf;
-    const auto previewAnimationOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ContextMenuAnimationOptions previewAnimationOptions_buf = {};
-    previewAnimationOptions_buf.tag = previewAnimationOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((previewAnimationOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.colorFilter = colorFilter_buf;
+    const auto syncLoad_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean syncLoad_buf = {};
+    syncLoad_buf.tag = syncLoad_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((syncLoad_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        previewAnimationOptions_buf.value = ContextMenuAnimationOptions_serializer::read(valueDeserializer);
+        syncLoad_buf.value = valueDeserializer.readBoolean();
     }
-    value.previewAnimationOptions = previewAnimationOptions_buf;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+    value.syncLoad = syncLoad_buf;
+    return value;
+}
+inline void RichEditorImageSpanStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_size = value.size;
+    Ark_Int32 value_size_type = INTEROP_RUNTIME_UNDEFINED;
+    value_size_type = runtimeType(value_size);
+    valueSerializer.writeInt8(value_size_type);
+    if ((value_size_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_size_value = value_size.value;
+        const auto value_size_value_0 = value_size_value.value0;
+        Ark_Int32 value_size_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+        value_size_value_0_type = value_size_value_0.selector;
+        if (value_size_value_0_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_size_value_0_0 = value_size_value_0.value0;
+            valueSerializer.writeString(value_size_value_0_0);
         }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (value_size_value_0_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_size_value_0_1 = value_size_value_0.value1;
+            valueSerializer.writeNumber(value_size_value_0_1);
         }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        else if (value_size_value_0_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_size_value_0_2 = value_size_value_0.value2;
+            Resource_serializer::write(valueSerializer, value_size_value_0_2);
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        const auto value_size_value_1 = value_size_value.value1;
+        Ark_Int32 value_size_value_1_type = INTEROP_RUNTIME_UNDEFINED;
+        value_size_value_1_type = value_size_value_1.selector;
+        if (value_size_value_1_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_size_value_1_0 = value_size_value_1.value0;
+            valueSerializer.writeString(value_size_value_1_0);
         }
-        else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        else if (value_size_value_1_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_size_value_1_1 = value_size_value_1.value1;
+            valueSerializer.writeNumber(value_size_value_1_1);
+        }
+        else if (value_size_value_1_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_size_value_1_2 = value_size_value_1.value2;
+            Resource_serializer::write(valueSerializer, value_size_value_1_2);
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
-    }
-    value.backgroundColor = backgroundColor_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
-    }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
-    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
     }
-    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
-    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
-    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
+    const auto value_verticalAlign = value.verticalAlign;
+    Ark_Int32 value_verticalAlign_type = INTEROP_RUNTIME_UNDEFINED;
+    value_verticalAlign_type = runtimeType(value_verticalAlign);
+    valueSerializer.writeInt8(value_verticalAlign_type);
+    if ((value_verticalAlign_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_verticalAlign_value = value_verticalAlign.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign_value));
     }
-    value.backgroundEffect = backgroundEffect_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    const auto value_objectFit = value.objectFit;
+    Ark_Int32 value_objectFit_type = INTEROP_RUNTIME_UNDEFINED;
+    value_objectFit_type = runtimeType(value_objectFit);
+    valueSerializer.writeInt8(value_objectFit_type);
+    if ((value_objectFit_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_objectFit_value = value_objectFit.value;
+        valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit_value));
     }
-    value.transition = transition_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+    const auto value_layoutStyle = value.layoutStyle;
+    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutStyle_type = runtimeType(value_layoutStyle);
+    valueSerializer.writeInt8(value_layoutStyle_type);
+    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutStyle_value = value_layoutStyle.value;
+        RichEditorLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto outlineColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceColor_EdgeColors outlineColor_buf = {};
-    outlineColor_buf.tag = outlineColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((outlineColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+}
+inline Ark_RichEditorImageSpanStyle RichEditorImageSpanStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorImageSpanStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto size_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Tuple_Dimension_Dimension size_buf = {};
+    size_buf.tag = size_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((size_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 outlineColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceColor_EdgeColors outlineColor_buf_ = {};
-        outlineColor_buf_.selector = outlineColor_buf__selector;
-        if (outlineColor_buf__selector == 0) {
-            outlineColor_buf_.selector = 0;
-            const Ark_Int8 outlineColor_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor outlineColor_buf__u = {};
-            outlineColor_buf__u.selector = outlineColor_buf__u_selector;
-            if (outlineColor_buf__u_selector == 0) {
-                outlineColor_buf__u.selector = 0;
-                outlineColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-            }
-            else if (outlineColor_buf__u_selector == 1) {
-                outlineColor_buf__u.selector = 1;
-                outlineColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (outlineColor_buf__u_selector == 2) {
-                outlineColor_buf__u.selector = 2;
-                outlineColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (outlineColor_buf__u_selector == 3) {
-                outlineColor_buf__u.selector = 3;
-                outlineColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.");
-            }
-            outlineColor_buf_.value0 = static_cast<Ark_ResourceColor>(outlineColor_buf__u);
+        Ark_Tuple_Dimension_Dimension size_buf_ = {};
+        const Ark_Int8 size_buf__value0_buf_selector = valueDeserializer.readInt8();
+        Ark_Dimension size_buf__value0_buf = {};
+        size_buf__value0_buf.selector = size_buf__value0_buf_selector;
+        if (size_buf__value0_buf_selector == 0) {
+            size_buf__value0_buf.selector = 0;
+            size_buf__value0_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (outlineColor_buf__selector == 1) {
-            outlineColor_buf_.selector = 1;
-            outlineColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
+        else if (size_buf__value0_buf_selector == 1) {
+            size_buf__value0_buf.selector = 1;
+            size_buf__value0_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (size_buf__value0_buf_selector == 2) {
+            size_buf__value0_buf.selector = 2;
+            size_buf__value0_buf.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for size_buf__value0_buf has to be chosen through deserialisation.");
         }
-        outlineColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(outlineColor_buf_);
-    }
-    value.outlineColor = outlineColor_buf;
-    const auto outlineWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth_buf = {};
-    outlineWidth_buf.tag = outlineWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((outlineWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 outlineWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_EdgeOutlineWidths outlineWidth_buf_ = {};
-        outlineWidth_buf_.selector = outlineWidth_buf__selector;
-        if (outlineWidth_buf__selector == 0) {
-            outlineWidth_buf_.selector = 0;
-            const Ark_Int8 outlineWidth_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension outlineWidth_buf__u = {};
-            outlineWidth_buf__u.selector = outlineWidth_buf__u_selector;
-            if (outlineWidth_buf__u_selector == 0) {
-                outlineWidth_buf__u.selector = 0;
-                outlineWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (outlineWidth_buf__u_selector == 1) {
-                outlineWidth_buf__u.selector = 1;
-                outlineWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (outlineWidth_buf__u_selector == 2) {
-                outlineWidth_buf__u.selector = 2;
-                outlineWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.");
-            }
-            outlineWidth_buf_.value0 = static_cast<Ark_Dimension>(outlineWidth_buf__u);
+        size_buf_.value0 = static_cast<Ark_Dimension>(size_buf__value0_buf);
+        const Ark_Int8 size_buf__value1_buf_selector = valueDeserializer.readInt8();
+        Ark_Dimension size_buf__value1_buf = {};
+        size_buf__value1_buf.selector = size_buf__value1_buf_selector;
+        if (size_buf__value1_buf_selector == 0) {
+            size_buf__value1_buf.selector = 0;
+            size_buf__value1_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (outlineWidth_buf__selector == 1) {
-            outlineWidth_buf_.selector = 1;
-            outlineWidth_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+        else if (size_buf__value1_buf_selector == 1) {
+            size_buf__value1_buf.selector = 1;
+            size_buf__value1_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (size_buf__value1_buf_selector == 2) {
+            size_buf__value1_buf.selector = 2;
+            size_buf__value1_buf.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for size_buf__value1_buf has to be chosen through deserialisation.");
         }
-        outlineWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(outlineWidth_buf_);
+        size_buf_.value1 = static_cast<Ark_Dimension>(size_buf__value1_buf);
+        size_buf.value = size_buf_;
     }
-    value.outlineWidth = outlineWidth_buf;
-    const auto hapticFeedbackMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HapticFeedbackMode hapticFeedbackMode_buf = {};
-    hapticFeedbackMode_buf.tag = hapticFeedbackMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hapticFeedbackMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.size = size_buf;
+    const auto verticalAlign_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageSpanAlignment verticalAlign_buf = {};
+    verticalAlign_buf.tag = verticalAlign_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((verticalAlign_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hapticFeedbackMode_buf.value = static_cast<Ark_HapticFeedbackMode>(valueDeserializer.readInt32());
+        verticalAlign_buf.value = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
     }
-    value.hapticFeedbackMode = hapticFeedbackMode_buf;
+    value.verticalAlign = verticalAlign_buf;
+    const auto objectFit_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ImageFit objectFit_buf = {};
+    objectFit_buf.tag = objectFit_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((objectFit_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        objectFit_buf.value = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
+    }
+    value.objectFit = objectFit_buf;
+    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorLayoutStyle layoutStyle_buf = {};
+    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        layoutStyle_buf.value = RichEditorLayoutStyle_serializer::read(valueDeserializer);
+    }
+    value.layoutStyle = layoutStyle_buf;
     return value;
 }
-inline void CustomPopupOptions_serializer::write(SerializerBase& buffer, Ark_CustomPopupOptions value)
+inline void RichEditorImageSpanStyleResult_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanStyleResult value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_builder = value.builder;
-    valueSerializer.writeCallbackResource(value_builder.resource);
-    valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder.call));
-    valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_builder.callSync));
-    const auto value_placement = value.placement;
-    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placement_type = runtimeType(value_placement);
-    valueSerializer.writeInt8(value_placement_type);
-    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placement_value = value_placement.value;
-        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
-    }
-    const auto value_popupColor = value.popupColor;
-    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_popupColor_type = runtimeType(value_popupColor);
-    valueSerializer.writeInt8(value_popupColor_type);
-    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_popupColor_value = value_popupColor.value;
-        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_popupColor_value_type = value_popupColor_value.selector;
-        if (value_popupColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_popupColor_value_0 = value_popupColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
-        }
-        else if (value_popupColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_popupColor_value_1 = value_popupColor_value.value1;
-            valueSerializer.writeString(value_popupColor_value_1);
-        }
-        else if (value_popupColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_popupColor_value_2 = value_popupColor_value.value2;
-            Resource_serializer::write(valueSerializer, value_popupColor_value_2);
-        }
-        else if (value_popupColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_popupColor_value_3 = value_popupColor_value.value3;
-            valueSerializer.writeNumber(value_popupColor_value_3);
-        }
-    }
-    const auto value_enableArrow = value.enableArrow;
-    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableArrow_type = runtimeType(value_enableArrow);
-    valueSerializer.writeInt8(value_enableArrow_type);
-    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableArrow_value = value_enableArrow.value;
-        valueSerializer.writeBoolean(value_enableArrow_value);
-    }
-    const auto value_autoCancel = value.autoCancel;
-    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_autoCancel_type = runtimeType(value_autoCancel);
-    valueSerializer.writeInt8(value_autoCancel_type);
-    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_autoCancel_value = value_autoCancel.value;
-        valueSerializer.writeBoolean(value_autoCancel_value);
+    const auto value_size = value.size;
+    const auto value_size_0 = value_size.value0;
+    valueSerializer.writeNumber(value_size_0);
+    const auto value_size_1 = value_size.value1;
+    valueSerializer.writeNumber(value_size_1);
+    const auto value_verticalAlign = value.verticalAlign;
+    valueSerializer.writeInt32(static_cast<Ark_ImageSpanAlignment>(value_verticalAlign));
+    const auto value_objectFit = value.objectFit;
+    valueSerializer.writeInt32(static_cast<Ark_ImageFit>(value_objectFit));
+    const auto value_layoutStyle = value.layoutStyle;
+    Ark_Int32 value_layoutStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_layoutStyle_type = runtimeType(value_layoutStyle);
+    valueSerializer.writeInt8(value_layoutStyle_type);
+    if ((value_layoutStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_layoutStyle_value = value_layoutStyle.value;
+        RichEditorLayoutStyle_serializer::write(valueSerializer, value_layoutStyle_value);
     }
-    const auto value_onStateChange = value.onStateChange;
-    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onStateChange_type = runtimeType(value_onStateChange);
-    valueSerializer.writeInt8(value_onStateChange_type);
-    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onStateChange_value = value_onStateChange.value;
-        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
+}
+inline Ark_RichEditorImageSpanStyleResult RichEditorImageSpanStyleResult_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorImageSpanStyleResult value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    Ark_Tuple_Number_Number size_buf = {};
+    size_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    size_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.size = size_buf;
+    value.verticalAlign = static_cast<Ark_ImageSpanAlignment>(valueDeserializer.readInt32());
+    value.objectFit = static_cast<Ark_ImageFit>(valueDeserializer.readInt32());
+    const auto layoutStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorLayoutStyle layoutStyle_buf = {};
+    layoutStyle_buf.tag = layoutStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((layoutStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        layoutStyle_buf.value = RichEditorLayoutStyle_serializer::read(valueDeserializer);
     }
-    const auto value_arrowOffset = value.arrowOffset;
-    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowOffset_type = runtimeType(value_arrowOffset);
-    valueSerializer.writeInt8(value_arrowOffset_type);
-    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowOffset_value = value_arrowOffset.value;
-        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowOffset_value_type = value_arrowOffset_value.selector;
-        if (value_arrowOffset_value_type == 0) {
+    value.layoutStyle = layoutStyle_buf;
+    return value;
+}
+inline void RichEditorParagraphResult_serializer::write(SerializerBase& buffer, Ark_RichEditorParagraphResult value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_style = value.style;
+    RichEditorParagraphStyle_serializer::write(valueSerializer, value_style);
+    const auto value_range = value.range;
+    const auto value_range_0 = value_range.value0;
+    valueSerializer.writeNumber(value_range_0);
+    const auto value_range_1 = value_range.value1;
+    valueSerializer.writeNumber(value_range_1);
+}
+inline Ark_RichEditorParagraphResult RichEditorParagraphResult_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorParagraphResult value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.style = RichEditorParagraphStyle_serializer::read(valueDeserializer);
+    Ark_Tuple_Number_Number range_buf = {};
+    range_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    range_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.range = range_buf;
+    return value;
+}
+inline void RichEditorTextStyle_serializer::write(SerializerBase& buffer, Ark_RichEditorTextStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_fontColor = value.fontColor;
+    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontColor_type = runtimeType(value_fontColor);
+    valueSerializer.writeInt8(value_fontColor_type);
+    if ((value_fontColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontColor_value = value_fontColor.value;
+        Ark_Int32 value_fontColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontColor_value_type = value_fontColor_value.selector;
+        if (value_fontColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
-            valueSerializer.writeString(value_arrowOffset_value_0);
+            const auto value_fontColor_value_0 = value_fontColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_value_0));
         }
-        else if (value_arrowOffset_value_type == 1) {
+        else if (value_fontColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
-            valueSerializer.writeNumber(value_arrowOffset_value_1);
+            const auto value_fontColor_value_1 = value_fontColor_value.value1;
+            valueSerializer.writeNumber(value_fontColor_value_1);
         }
-        else if (value_arrowOffset_value_type == 2) {
+        else if (value_fontColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
-        }
-    }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
-    }
-    const auto value_mask = value.mask;
-    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
-    value_mask_type = runtimeType(value_mask);
-    valueSerializer.writeInt8(value_mask_type);
-    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_mask_value = value_mask.value;
-        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_mask_value_type = value_mask_value.selector;
-        if (value_mask_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_mask_value_0 = value_mask_value.value0;
-            valueSerializer.writeBoolean(value_mask_value_0);
+            const auto value_fontColor_value_2 = value_fontColor_value.value2;
+            valueSerializer.writeString(value_fontColor_value_2);
         }
-        else if (value_mask_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_mask_value_1 = value_mask_value.value1;
-            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
+        else if (value_fontColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_fontColor_value_3 = value_fontColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_fontColor_value_3);
         }
     }
-    const auto value_targetSpace = value.targetSpace;
-    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
-    value_targetSpace_type = runtimeType(value_targetSpace);
-    valueSerializer.writeInt8(value_targetSpace_type);
-    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_targetSpace_value = value_targetSpace.value;
-        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_targetSpace_value_type = value_targetSpace_value.selector;
-        if (value_targetSpace_value_type == 0) {
+    const auto value_fontSize = value.fontSize;
+    Ark_Int32 value_fontSize_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontSize_type = runtimeType(value_fontSize);
+    valueSerializer.writeInt8(value_fontSize_type);
+    if ((value_fontSize_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontSize_value = value_fontSize.value;
+        Ark_Int32 value_fontSize_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontSize_value_type = value_fontSize_value.selector;
+        if (value_fontSize_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
-            valueSerializer.writeString(value_targetSpace_value_0);
+            const auto value_fontSize_value_0 = value_fontSize_value.value0;
+            valueSerializer.writeString(value_fontSize_value_0);
         }
-        else if (value_targetSpace_value_type == 1) {
+        else if (value_fontSize_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
-            valueSerializer.writeNumber(value_targetSpace_value_1);
+            const auto value_fontSize_value_1 = value_fontSize_value.value1;
+            valueSerializer.writeNumber(value_fontSize_value_1);
         }
-        else if (value_targetSpace_value_type == 2) {
+        else if (value_fontSize_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
-            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
+            const auto value_fontSize_value_2 = value_fontSize_value.value2;
+            Resource_serializer::write(valueSerializer, value_fontSize_value_2);
         }
     }
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
+    const auto value_fontStyle = value.fontStyle;
+    Ark_Int32 value_fontStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontStyle_type = runtimeType(value_fontStyle);
+    valueSerializer.writeInt8(value_fontStyle_type);
+    if ((value_fontStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontStyle_value = value_fontStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle_value));
     }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if (value_width_value_type == 0) {
+    const auto value_fontWeight = value.fontWeight;
+    Ark_Int32 value_fontWeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontWeight_type = runtimeType(value_fontWeight);
+    valueSerializer.writeInt8(value_fontWeight_type);
+    if ((value_fontWeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontWeight_value = value_fontWeight.value;
+        Ark_Int32 value_fontWeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontWeight_value_type = value_fontWeight_value.selector;
+        if (value_fontWeight_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            valueSerializer.writeString(value_width_value_0);
+            const auto value_fontWeight_value_0 = value_fontWeight_value.value0;
+            valueSerializer.writeNumber(value_fontWeight_value_0);
         }
-        else if (value_width_value_type == 1) {
+        else if (value_fontWeight_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            valueSerializer.writeNumber(value_width_value_1);
+            const auto value_fontWeight_value_1 = value_fontWeight_value.value1;
+            valueSerializer.writeInt32(static_cast<Ark_FontWeight>(value_fontWeight_value_1));
         }
-        else if (value_width_value_type == 2) {
+        else if (value_fontWeight_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_width_value_2 = value_width_value.value2;
-            Resource_serializer::write(valueSerializer, value_width_value_2);
+            const auto value_fontWeight_value_2 = value_fontWeight_value.value2;
+            valueSerializer.writeString(value_fontWeight_value_2);
         }
     }
-    const auto value_arrowPointPosition = value.arrowPointPosition;
-    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
-    valueSerializer.writeInt8(value_arrowPointPosition_type);
-    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
-        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
-    }
-    const auto value_arrowWidth = value.arrowWidth;
-    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowWidth_type = runtimeType(value_arrowWidth);
-    valueSerializer.writeInt8(value_arrowWidth_type);
-    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowWidth_value = value_arrowWidth.value;
-        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowWidth_value_type = value_arrowWidth_value.selector;
-        if (value_arrowWidth_value_type == 0) {
+    const auto value_fontFamily = value.fontFamily;
+    Ark_Int32 value_fontFamily_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontFamily_type = runtimeType(value_fontFamily);
+    valueSerializer.writeInt8(value_fontFamily_type);
+    if ((value_fontFamily_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontFamily_value = value_fontFamily.value;
+        Ark_Int32 value_fontFamily_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_fontFamily_value_type = value_fontFamily_value.selector;
+        if (value_fontFamily_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
-            valueSerializer.writeString(value_arrowWidth_value_0);
+            const auto value_fontFamily_value_0 = value_fontFamily_value.value0;
+            valueSerializer.writeString(value_fontFamily_value_0);
         }
-        else if (value_arrowWidth_value_type == 1) {
+        else if (value_fontFamily_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
-            valueSerializer.writeNumber(value_arrowWidth_value_1);
-        }
-        else if (value_arrowWidth_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
+            const auto value_fontFamily_value_1 = value_fontFamily_value.value1;
+            Resource_serializer::write(valueSerializer, value_fontFamily_value_1);
         }
     }
-    const auto value_arrowHeight = value.arrowHeight;
-    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowHeight_type = runtimeType(value_arrowHeight);
-    valueSerializer.writeInt8(value_arrowHeight_type);
-    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowHeight_value = value_arrowHeight.value;
-        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowHeight_value_type = value_arrowHeight_value.selector;
-        if (value_arrowHeight_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
-            valueSerializer.writeString(value_arrowHeight_value_0);
-        }
-        else if (value_arrowHeight_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
-            valueSerializer.writeNumber(value_arrowHeight_value_1);
-        }
-        else if (value_arrowHeight_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
-        }
+    const auto value_decoration = value.decoration;
+    Ark_Int32 value_decoration_type = INTEROP_RUNTIME_UNDEFINED;
+    value_decoration_type = runtimeType(value_decoration);
+    valueSerializer.writeInt8(value_decoration_type);
+    if ((value_decoration_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_decoration_value = value_decoration.value;
+        DecorationStyleInterface_serializer::write(valueSerializer, value_decoration_value);
     }
-    const auto value_radius = value.radius;
-    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_radius_type = runtimeType(value_radius);
-    valueSerializer.writeInt8(value_radius_type);
-    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_radius_value = value_radius.value;
-        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_radius_value_type = value_radius_value.selector;
-        if (value_radius_value_type == 0) {
+    const auto value_textShadow = value.textShadow;
+    Ark_Int32 value_textShadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textShadow_type = runtimeType(value_textShadow);
+    valueSerializer.writeInt8(value_textShadow_type);
+    if ((value_textShadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textShadow_value = value_textShadow.value;
+        Ark_Int32 value_textShadow_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_textShadow_value_type = value_textShadow_value.selector;
+        if (value_textShadow_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_radius_value_0 = value_radius_value.value0;
-            valueSerializer.writeString(value_radius_value_0);
+            const auto value_textShadow_value_0 = value_textShadow_value.value0;
+            ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_0);
         }
-        else if (value_radius_value_type == 1) {
+        else if (value_textShadow_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_radius_value_1 = value_radius_value.value1;
-            valueSerializer.writeNumber(value_radius_value_1);
-        }
-        else if (value_radius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_radius_value_2 = value_radius_value.value2;
-            Resource_serializer::write(valueSerializer, value_radius_value_2);
+            const auto value_textShadow_value_1 = value_textShadow_value.value1;
+            valueSerializer.writeInt32(value_textShadow_value_1.length);
+            for (int value_textShadow_value_1_counter_i = 0; value_textShadow_value_1_counter_i < value_textShadow_value_1.length; value_textShadow_value_1_counter_i++) {
+                const Ark_ShadowOptions value_textShadow_value_1_element = value_textShadow_value_1.array[value_textShadow_value_1_counter_i];
+                ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_1_element);
+            }
         }
     }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
+    const auto value_letterSpacing = value.letterSpacing;
+    Ark_Int32 value_letterSpacing_type = INTEROP_RUNTIME_UNDEFINED;
+    value_letterSpacing_type = runtimeType(value_letterSpacing);
+    valueSerializer.writeInt8(value_letterSpacing_type);
+    if ((value_letterSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_letterSpacing_value = value_letterSpacing.value;
+        Ark_Int32 value_letterSpacing_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_letterSpacing_value_type = value_letterSpacing_value.selector;
+        if (value_letterSpacing_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
+            const auto value_letterSpacing_value_0 = value_letterSpacing_value.value0;
+            valueSerializer.writeNumber(value_letterSpacing_value_0);
         }
-        else if (value_shadow_value_type == 1) {
+        else if (value_letterSpacing_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
+            const auto value_letterSpacing_value_1 = value_letterSpacing_value.value1;
+            valueSerializer.writeString(value_letterSpacing_value_1);
         }
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
-    }
-    const auto value_focusable = value.focusable;
-    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
-    value_focusable_type = runtimeType(value_focusable);
-    valueSerializer.writeInt8(value_focusable_type);
-    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_focusable_value = value_focusable.value;
-        valueSerializer.writeBoolean(value_focusable_value);
-    }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
-    }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
-        if (value_onWillDismiss_value_type == 0) {
+    const auto value_lineHeight = value.lineHeight;
+    Ark_Int32 value_lineHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lineHeight_type = runtimeType(value_lineHeight);
+    valueSerializer.writeInt8(value_lineHeight_type);
+    if ((value_lineHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lineHeight_value = value_lineHeight.value;
+        Ark_Int32 value_lineHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_lineHeight_value_type = value_lineHeight_value.selector;
+        if (value_lineHeight_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
-            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
+            const auto value_lineHeight_value_0 = value_lineHeight_value.value0;
+            valueSerializer.writeNumber(value_lineHeight_value_0);
         }
-        else if (value_onWillDismiss_value_type == 1) {
+        else if (value_lineHeight_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
-            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
+            const auto value_lineHeight_value_1 = value_lineHeight_value.value1;
+            valueSerializer.writeString(value_lineHeight_value_1);
+        }
+        else if (value_lineHeight_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value_lineHeight_value_2 = value_lineHeight_value.value2;
+            Resource_serializer::write(valueSerializer, value_lineHeight_value_2);
         }
     }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHoverMode_value = value_enableHoverMode.value;
-        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    const auto value_halfLeading = value.halfLeading;
+    Ark_Int32 value_halfLeading_type = INTEROP_RUNTIME_UNDEFINED;
+    value_halfLeading_type = runtimeType(value_halfLeading);
+    valueSerializer.writeInt8(value_halfLeading_type);
+    if ((value_halfLeading_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_halfLeading_value = value_halfLeading.value;
+        valueSerializer.writeBoolean(value_halfLeading_value);
     }
-    const auto value_followTransformOfTarget = value.followTransformOfTarget;
-    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
-    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
-    valueSerializer.writeInt8(value_followTransformOfTarget_type);
-    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
-        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
+    const auto value_fontFeature = value.fontFeature;
+    Ark_Int32 value_fontFeature_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontFeature_type = runtimeType(value_fontFeature);
+    valueSerializer.writeInt8(value_fontFeature_type);
+    if ((value_fontFeature_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontFeature_value = value_fontFeature.value;
+        valueSerializer.writeString(value_fontFeature_value);
     }
-    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
-    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
-    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
-    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
+    const auto value_textBackgroundStyle = value.textBackgroundStyle;
+    Ark_Int32 value_textBackgroundStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textBackgroundStyle_type = runtimeType(value_textBackgroundStyle);
+    valueSerializer.writeInt8(value_textBackgroundStyle_type);
+    if ((value_textBackgroundStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textBackgroundStyle_value = value_textBackgroundStyle.value;
+        TextBackgroundStyle_serializer::write(valueSerializer, value_textBackgroundStyle_value);
     }
 }
-inline Ark_CustomPopupOptions CustomPopupOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_RichEditorTextStyle RichEditorTextStyle_serializer::read(DeserializerBase& buffer)
 {
-    Ark_CustomPopupOptions value = {};
+    Ark_RichEditorTextStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.builder = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
-    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Placement placement_buf = {};
-    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
-    }
-    value.placement = placement_buf;
-    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Color_String_Resource_Number popupColor_buf = {};
-    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Color_String_Resource_Number popupColor_buf_ = {};
-        popupColor_buf_.selector = popupColor_buf__selector;
-        if (popupColor_buf__selector == 0) {
-            popupColor_buf_.selector = 0;
-            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (popupColor_buf__selector == 1) {
-            popupColor_buf_.selector = 1;
-            popupColor_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (popupColor_buf__selector == 2) {
-            popupColor_buf_.selector = 2;
-            popupColor_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else if (popupColor_buf__selector == 3) {
-            popupColor_buf_.selector = 3;
-            popupColor_buf_.value3 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
-        }
-        popupColor_buf.value = static_cast<Ark_Union_Color_String_Resource_Number>(popupColor_buf_);
-    }
-    value.popupColor = popupColor_buf;
-    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableArrow_buf = {};
-    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableArrow_buf.value = valueDeserializer.readBoolean();
-    }
-    value.enableArrow = enableArrow_buf;
-    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean autoCancel_buf = {};
-    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        autoCancel_buf.value = valueDeserializer.readBoolean();
-    }
-    value.autoCancel = autoCancel_buf;
-    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupStateChangeCallback onStateChange_buf = {};
-    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
-    }
-    value.onStateChange = onStateChange_buf;
-    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length arrowOffset_buf = {};
-    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
-        Ark_Length arrowOffset_buf_ = {};
-        arrowOffset_buf_.selector = arrowOffset_buf__selector;
-        if (arrowOffset_buf__selector == 0) {
-            arrowOffset_buf_.selector = 0;
-            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowOffset_buf__selector == 1) {
-            arrowOffset_buf_.selector = 1;
-            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowOffset_buf__selector == 2) {
-            arrowOffset_buf_.selector = 2;
-            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
-        }
-        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
-    }
-    value.arrowOffset = arrowOffset_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
-    }
-    value.showInSubWindow = showInSubWindow_buf;
-    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_PopupMaskType mask_buf = {};
-    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto fontColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor fontColor_buf = {};
+    fontColor_buf.tag = fontColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
-        mask_buf_.selector = mask_buf__selector;
-        if (mask_buf__selector == 0) {
-            mask_buf_.selector = 0;
-            mask_buf_.value0 = valueDeserializer.readBoolean();
+        const Ark_Int8 fontColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor fontColor_buf_ = {};
+        fontColor_buf_.selector = fontColor_buf__selector;
+        if (fontColor_buf__selector == 0) {
+            fontColor_buf_.selector = 0;
+            fontColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (mask_buf__selector == 1) {
-            mask_buf_.selector = 1;
-            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
+        else if (fontColor_buf__selector == 1) {
+            fontColor_buf_.selector = 1;
+            fontColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        }
+        else if (fontColor_buf__selector == 2) {
+            fontColor_buf_.selector = 2;
+            fontColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (fontColor_buf__selector == 3) {
+            fontColor_buf_.selector = 3;
+            fontColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for fontColor_buf_ has to be chosen through deserialisation.");
         }
-        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
+        fontColor_buf.value = static_cast<Ark_ResourceColor>(fontColor_buf_);
     }
-    value.mask = mask_buf;
-    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length targetSpace_buf = {};
-    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontColor = fontColor_buf;
+    const auto fontSize_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_String_Number_Resource fontSize_buf = {};
+    fontSize_buf.tag = fontSize_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontSize_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
-        Ark_Length targetSpace_buf_ = {};
-        targetSpace_buf_.selector = targetSpace_buf__selector;
-        if (targetSpace_buf__selector == 0) {
-            targetSpace_buf_.selector = 0;
-            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 fontSize_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_String_Number_Resource fontSize_buf_ = {};
+        fontSize_buf_.selector = fontSize_buf__selector;
+        if (fontSize_buf__selector == 0) {
+            fontSize_buf_.selector = 0;
+            fontSize_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (targetSpace_buf__selector == 1) {
-            targetSpace_buf_.selector = 1;
-            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (fontSize_buf__selector == 1) {
+            fontSize_buf_.selector = 1;
+            fontSize_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (targetSpace_buf__selector == 2) {
-            targetSpace_buf_.selector = 2;
-            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (fontSize_buf__selector == 2) {
+            fontSize_buf_.selector = 2;
+            fontSize_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for fontSize_buf_ has to be chosen through deserialisation.");
         }
-        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
+        fontSize_buf.value = static_cast<Ark_Union_String_Number_Resource>(fontSize_buf_);
     }
-    value.targetSpace = targetSpace_buf;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontSize = fontSize_buf;
+    const auto fontStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_FontStyle fontStyle_buf = {};
+    fontStyle_buf.tag = fontStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
+        fontStyle_buf.value = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
     }
-    value.offset = offset_buf;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontStyle = fontStyle_buf;
+    const auto fontWeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_FontWeight_String fontWeight_buf = {};
+    fontWeight_buf.tag = fontWeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontWeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension width_buf_ = {};
-        width_buf_.selector = width_buf__selector;
-        if (width_buf__selector == 0) {
-            width_buf_.selector = 0;
-            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        const Ark_Int8 fontWeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_FontWeight_String fontWeight_buf_ = {};
+        fontWeight_buf_.selector = fontWeight_buf__selector;
+        if (fontWeight_buf__selector == 0) {
+            fontWeight_buf_.selector = 0;
+            fontWeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        else if (fontWeight_buf__selector == 1) {
+            fontWeight_buf_.selector = 1;
+            fontWeight_buf_.value1 = static_cast<Ark_FontWeight>(valueDeserializer.readInt32());
         }
-        else if (width_buf__selector == 2) {
-            width_buf_.selector = 2;
-            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (fontWeight_buf__selector == 2) {
+            fontWeight_buf_.selector = 2;
+            fontWeight_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
         else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for fontWeight_buf_ has to be chosen through deserialisation.");
         }
-        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
-    }
-    value.width = width_buf;
-    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ArrowPointPosition arrowPointPosition_buf = {};
-    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
+        fontWeight_buf.value = static_cast<Ark_Union_Number_FontWeight_String>(fontWeight_buf_);
     }
-    value.arrowPointPosition = arrowPointPosition_buf;
-    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowWidth_buf = {};
-    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontWeight = fontWeight_buf;
+    const auto fontFamily_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceStr fontFamily_buf = {};
+    fontFamily_buf.tag = fontFamily_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontFamily_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowWidth_buf_ = {};
-        arrowWidth_buf_.selector = arrowWidth_buf__selector;
-        if (arrowWidth_buf__selector == 0) {
-            arrowWidth_buf_.selector = 0;
-            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowWidth_buf__selector == 1) {
-            arrowWidth_buf_.selector = 1;
-            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 fontFamily_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceStr fontFamily_buf_ = {};
+        fontFamily_buf_.selector = fontFamily_buf__selector;
+        if (fontFamily_buf__selector == 0) {
+            fontFamily_buf_.selector = 0;
+            fontFamily_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (arrowWidth_buf__selector == 2) {
-            arrowWidth_buf_.selector = 2;
-            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (fontFamily_buf__selector == 1) {
+            fontFamily_buf_.selector = 1;
+            fontFamily_buf_.value1 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for fontFamily_buf_ has to be chosen through deserialisation.");
         }
-        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
+        fontFamily_buf.value = static_cast<Ark_ResourceStr>(fontFamily_buf_);
     }
-    value.arrowWidth = arrowWidth_buf;
-    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowHeight_buf = {};
-    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontFamily = fontFamily_buf;
+    const auto decoration_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_DecorationStyleInterface decoration_buf = {};
+    decoration_buf.tag = decoration_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((decoration_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowHeight_buf_ = {};
-        arrowHeight_buf_.selector = arrowHeight_buf__selector;
-        if (arrowHeight_buf__selector == 0) {
-            arrowHeight_buf_.selector = 0;
-            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowHeight_buf__selector == 1) {
-            arrowHeight_buf_.selector = 1;
-            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        decoration_buf.value = DecorationStyleInterface_serializer::read(valueDeserializer);
+    }
+    value.decoration = decoration_buf;
+    const auto textShadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_Array_ShadowOptions textShadow_buf = {};
+    textShadow_buf.tag = textShadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textShadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 textShadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_Array_ShadowOptions textShadow_buf_ = {};
+        textShadow_buf_.selector = textShadow_buf__selector;
+        if (textShadow_buf__selector == 0) {
+            textShadow_buf_.selector = 0;
+            textShadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
         }
-        else if (arrowHeight_buf__selector == 2) {
-            arrowHeight_buf_.selector = 2;
-            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (textShadow_buf__selector == 1) {
+            textShadow_buf_.selector = 1;
+            const Ark_Int32 textShadow_buf__u_length = valueDeserializer.readInt32();
+            Array_ShadowOptions textShadow_buf__u = {};
+            valueDeserializer.resizeArray<std::decay<decltype(textShadow_buf__u)>::type,
+        std::decay<decltype(*textShadow_buf__u.array)>::type>(&textShadow_buf__u, textShadow_buf__u_length);
+            for (int textShadow_buf__u_i = 0; textShadow_buf__u_i < textShadow_buf__u_length; textShadow_buf__u_i++) {
+                textShadow_buf__u.array[textShadow_buf__u_i] = ShadowOptions_serializer::read(valueDeserializer);
+            }
+            textShadow_buf_.value1 = textShadow_buf__u;
         }
         else {
-            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for textShadow_buf_ has to be chosen through deserialisation.");
         }
-        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
+        textShadow_buf.value = static_cast<Ark_Union_ShadowOptions_Array_ShadowOptions>(textShadow_buf_);
     }
-    value.arrowHeight = arrowHeight_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.textShadow = textShadow_buf;
+    const auto letterSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_String letterSpacing_buf = {};
+    letterSpacing_buf.tag = letterSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((letterSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 letterSpacing_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_String letterSpacing_buf_ = {};
+        letterSpacing_buf_.selector = letterSpacing_buf__selector;
+        if (letterSpacing_buf__selector == 0) {
+            letterSpacing_buf_.selector = 0;
+            letterSpacing_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (radius_buf__selector == 2) {
-            radius_buf_.selector = 2;
-            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (letterSpacing_buf__selector == 1) {
+            letterSpacing_buf_.selector = 1;
+            letterSpacing_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
         }
         else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for letterSpacing_buf_ has to be chosen through deserialisation.");
         }
-        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
+        letterSpacing_buf.value = static_cast<Ark_Union_Number_String>(letterSpacing_buf_);
     }
-    value.radius = radius_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.letterSpacing = letterSpacing_buf;
+    const auto lineHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_String_Resource lineHeight_buf = {};
+    lineHeight_buf.tag = lineHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lineHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        const Ark_Int8 lineHeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_String_Resource lineHeight_buf_ = {};
+        lineHeight_buf_.selector = lineHeight_buf__selector;
+        if (lineHeight_buf__selector == 0) {
+            lineHeight_buf_.selector = 0;
+            lineHeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        else if (lineHeight_buf__selector == 1) {
+            lineHeight_buf_.selector = 1;
+            lineHeight_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
+        }
+        else if (lineHeight_buf__selector == 2) {
+            lineHeight_buf_.selector = 2;
+            lineHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for lineHeight_buf_ has to be chosen through deserialisation.");
         }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+        lineHeight_buf.value = static_cast<Ark_Union_Number_String_Resource>(lineHeight_buf_);
     }
-    value.shadow = shadow_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.lineHeight = lineHeight_buf;
+    const auto halfLeading_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean halfLeading_buf = {};
+    halfLeading_buf.tag = halfLeading_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((halfLeading_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+        halfLeading_buf.value = valueDeserializer.readBoolean();
     }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean focusable_buf = {};
-    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.halfLeading = halfLeading_buf;
+    const auto fontFeature_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String fontFeature_buf = {};
+    fontFeature_buf.tag = fontFeature_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontFeature_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        focusable_buf.value = valueDeserializer.readBoolean();
+        fontFeature_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.focusable = focusable_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.fontFeature = fontFeature_buf;
+    const auto textBackgroundStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextBackgroundStyle textBackgroundStyle_buf = {};
+    textBackgroundStyle_buf.tag = textBackgroundStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textBackgroundStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+        textBackgroundStyle_buf.value = TextBackgroundStyle_serializer::read(valueDeserializer);
     }
-    value.transition = transition_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
-        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
-        if (onWillDismiss_buf__selector == 0) {
-            onWillDismiss_buf_.selector = 0;
-            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
-        }
-        else if (onWillDismiss_buf__selector == 1) {
-            onWillDismiss_buf_.selector = 1;
-            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
+    value.textBackgroundStyle = textBackgroundStyle_buf;
+    return value;
+}
+inline void RichEditorTextStyleResult_serializer::write(SerializerBase& buffer, Ark_RichEditorTextStyleResult value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_fontColor = value.fontColor;
+    Ark_Int32 value_fontColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontColor_type = value_fontColor.selector;
+    if (value_fontColor_type == 0) {
+        valueSerializer.writeInt8(0);
+        const auto value_fontColor_0 = value_fontColor.value0;
+        valueSerializer.writeInt32(static_cast<Ark_Color>(value_fontColor_0));
+    }
+    else if (value_fontColor_type == 1) {
+        valueSerializer.writeInt8(1);
+        const auto value_fontColor_1 = value_fontColor.value1;
+        valueSerializer.writeNumber(value_fontColor_1);
+    }
+    else if (value_fontColor_type == 2) {
+        valueSerializer.writeInt8(2);
+        const auto value_fontColor_2 = value_fontColor.value2;
+        valueSerializer.writeString(value_fontColor_2);
+    }
+    else if (value_fontColor_type == 3) {
+        valueSerializer.writeInt8(3);
+        const auto value_fontColor_3 = value_fontColor.value3;
+        Resource_serializer::write(valueSerializer, value_fontColor_3);
+    }
+    const auto value_fontSize = value.fontSize;
+    valueSerializer.writeNumber(value_fontSize);
+    const auto value_fontStyle = value.fontStyle;
+    valueSerializer.writeInt32(static_cast<Ark_FontStyle>(value_fontStyle));
+    const auto value_fontWeight = value.fontWeight;
+    valueSerializer.writeNumber(value_fontWeight);
+    const auto value_fontFamily = value.fontFamily;
+    valueSerializer.writeString(value_fontFamily);
+    const auto value_decoration = value.decoration;
+    DecorationStyleResult_serializer::write(valueSerializer, value_decoration);
+    const auto value_textShadow = value.textShadow;
+    Ark_Int32 value_textShadow_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textShadow_type = runtimeType(value_textShadow);
+    valueSerializer.writeInt8(value_textShadow_type);
+    if ((value_textShadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textShadow_value = value_textShadow.value;
+        valueSerializer.writeInt32(value_textShadow_value.length);
+        for (int value_textShadow_value_counter_i = 0; value_textShadow_value_counter_i < value_textShadow_value.length; value_textShadow_value_counter_i++) {
+            const Ark_ShadowOptions value_textShadow_value_element = value_textShadow_value.array[value_textShadow_value_counter_i];
+            ShadowOptions_serializer::write(valueSerializer, value_textShadow_value_element);
         }
-        else {
-            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
+    }
+    const auto value_letterSpacing = value.letterSpacing;
+    Ark_Int32 value_letterSpacing_type = INTEROP_RUNTIME_UNDEFINED;
+    value_letterSpacing_type = runtimeType(value_letterSpacing);
+    valueSerializer.writeInt8(value_letterSpacing_type);
+    if ((value_letterSpacing_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_letterSpacing_value = value_letterSpacing.value;
+        valueSerializer.writeNumber(value_letterSpacing_value);
+    }
+    const auto value_lineHeight = value.lineHeight;
+    Ark_Int32 value_lineHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_lineHeight_type = runtimeType(value_lineHeight);
+    valueSerializer.writeInt8(value_lineHeight_type);
+    if ((value_lineHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_lineHeight_value = value_lineHeight.value;
+        valueSerializer.writeNumber(value_lineHeight_value);
+    }
+    const auto value_halfLeading = value.halfLeading;
+    Ark_Int32 value_halfLeading_type = INTEROP_RUNTIME_UNDEFINED;
+    value_halfLeading_type = runtimeType(value_halfLeading);
+    valueSerializer.writeInt8(value_halfLeading_type);
+    if ((value_halfLeading_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_halfLeading_value = value_halfLeading.value;
+        valueSerializer.writeBoolean(value_halfLeading_value);
+    }
+    const auto value_fontFeature = value.fontFeature;
+    Ark_Int32 value_fontFeature_type = INTEROP_RUNTIME_UNDEFINED;
+    value_fontFeature_type = runtimeType(value_fontFeature);
+    valueSerializer.writeInt8(value_fontFeature_type);
+    if ((value_fontFeature_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_fontFeature_value = value_fontFeature.value;
+        valueSerializer.writeString(value_fontFeature_value);
+    }
+    const auto value_textBackgroundStyle = value.textBackgroundStyle;
+    Ark_Int32 value_textBackgroundStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textBackgroundStyle_type = runtimeType(value_textBackgroundStyle);
+    valueSerializer.writeInt8(value_textBackgroundStyle_type);
+    if ((value_textBackgroundStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textBackgroundStyle_value = value_textBackgroundStyle.value;
+        TextBackgroundStyle_serializer::write(valueSerializer, value_textBackgroundStyle_value);
+    }
+}
+inline Ark_RichEditorTextStyleResult RichEditorTextStyleResult_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorTextStyleResult value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const Ark_Int8 fontColor_buf_selector = valueDeserializer.readInt8();
+    Ark_ResourceColor fontColor_buf = {};
+    fontColor_buf.selector = fontColor_buf_selector;
+    if (fontColor_buf_selector == 0) {
+        fontColor_buf.selector = 0;
+        fontColor_buf.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
+    }
+    else if (fontColor_buf_selector == 1) {
+        fontColor_buf.selector = 1;
+        fontColor_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    }
+    else if (fontColor_buf_selector == 2) {
+        fontColor_buf.selector = 2;
+        fontColor_buf.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    else if (fontColor_buf_selector == 3) {
+        fontColor_buf.selector = 3;
+        fontColor_buf.value3 = Resource_serializer::read(valueDeserializer);
+    }
+    else {
+        INTEROP_FATAL("One of the branches for fontColor_buf has to be chosen through deserialisation.");
+    }
+    value.fontColor = static_cast<Ark_ResourceColor>(fontColor_buf);
+    value.fontSize = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.fontStyle = static_cast<Ark_FontStyle>(valueDeserializer.readInt32());
+    value.fontWeight = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.fontFamily = static_cast<Ark_String>(valueDeserializer.readString());
+    value.decoration = DecorationStyleResult_serializer::read(valueDeserializer);
+    const auto textShadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Array_ShadowOptions textShadow_buf = {};
+    textShadow_buf.tag = textShadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textShadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int32 textShadow_buf__length = valueDeserializer.readInt32();
+        Array_ShadowOptions textShadow_buf_ = {};
+        valueDeserializer.resizeArray<std::decay<decltype(textShadow_buf_)>::type,
+        std::decay<decltype(*textShadow_buf_.array)>::type>(&textShadow_buf_, textShadow_buf__length);
+        for (int textShadow_buf__i = 0; textShadow_buf__i < textShadow_buf__length; textShadow_buf__i++) {
+            textShadow_buf_.array[textShadow_buf__i] = ShadowOptions_serializer::read(valueDeserializer);
         }
-        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
+        textShadow_buf.value = textShadow_buf_;
     }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.textShadow = textShadow_buf;
+    const auto letterSpacing_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number letterSpacing_buf = {};
+    letterSpacing_buf.tag = letterSpacing_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((letterSpacing_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+        letterSpacing_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean followTransformOfTarget_buf = {};
-    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.letterSpacing = letterSpacing_buf;
+    const auto lineHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number lineHeight_buf = {};
+    lineHeight_buf.tag = lineHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((lineHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
+        lineHeight_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.followTransformOfTarget = followTransformOfTarget_buf;
-    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
-    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.lineHeight = lineHeight_buf;
+    const auto halfLeading_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean halfLeading_buf = {};
+    halfLeading_buf.tag = halfLeading_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((halfLeading_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        halfLeading_buf.value = valueDeserializer.readBoolean();
+    }
+    value.halfLeading = halfLeading_buf;
+    const auto fontFeature_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String fontFeature_buf = {};
+    fontFeature_buf.tag = fontFeature_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((fontFeature_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        fontFeature_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
+    }
+    value.fontFeature = fontFeature_buf;
+    const auto textBackgroundStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextBackgroundStyle textBackgroundStyle_buf = {};
+    textBackgroundStyle_buf.tag = textBackgroundStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textBackgroundStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
+        textBackgroundStyle_buf.value = TextBackgroundStyle_serializer::read(valueDeserializer);
     }
-    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    value.textBackgroundStyle = textBackgroundStyle_buf;
     return value;
 }
-inline void MenuOptions_serializer::write(SerializerBase& buffer, Ark_MenuOptions value)
+inline void RichEditorUpdateImageSpanStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorUpdateImageSpanStyleOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
-    }
-    const auto value_placement = value.placement;
-    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placement_type = runtimeType(value_placement);
-    valueSerializer.writeInt8(value_placement_type);
-    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placement_value = value_placement.value;
-        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
-    }
-    const auto value_enableArrow = value.enableArrow;
-    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableArrow_type = runtimeType(value_enableArrow);
-    valueSerializer.writeInt8(value_enableArrow_type);
-    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableArrow_value = value_enableArrow.value;
-        valueSerializer.writeBoolean(value_enableArrow_value);
+    const auto value_start = value.start;
+    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
+    value_start_type = runtimeType(value_start);
+    valueSerializer.writeInt8(value_start_type);
+    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_start_value = value_start.value;
+        valueSerializer.writeNumber(value_start_value);
     }
-    const auto value_arrowOffset = value.arrowOffset;
-    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowOffset_type = runtimeType(value_arrowOffset);
-    valueSerializer.writeInt8(value_arrowOffset_type);
-    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowOffset_value = value_arrowOffset.value;
-        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowOffset_value_type = value_arrowOffset_value.selector;
-        if (value_arrowOffset_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
-            valueSerializer.writeString(value_arrowOffset_value_0);
-        }
-        else if (value_arrowOffset_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
-            valueSerializer.writeNumber(value_arrowOffset_value_1);
-        }
-        else if (value_arrowOffset_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
-        }
+    const auto value_end = value.end;
+    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
+    value_end_type = runtimeType(value_end);
+    valueSerializer.writeInt8(value_end_type);
+    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_end_value = value_end.value;
+        valueSerializer.writeNumber(value_end_value);
     }
-    const auto value_preview = value.preview;
-    Ark_Int32 value_preview_type = INTEROP_RUNTIME_UNDEFINED;
-    value_preview_type = runtimeType(value_preview);
-    valueSerializer.writeInt8(value_preview_type);
-    if ((value_preview_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_preview_value = value_preview.value;
-        Ark_Int32 value_preview_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_preview_value_type = value_preview_value.selector;
-        if (value_preview_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_preview_value_0 = value_preview_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_MenuPreviewMode>(value_preview_value_0));
-        }
-        else if (value_preview_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_preview_value_1 = value_preview_value.value1;
-            valueSerializer.writeCallbackResource(value_preview_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_preview_value_1.callSync));
-        }
+    const auto value_imageStyle = value.imageStyle;
+    RichEditorImageSpanStyle_serializer::write(valueSerializer, value_imageStyle);
+}
+inline Ark_RichEditorUpdateImageSpanStyleOptions RichEditorUpdateImageSpanStyleOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorUpdateImageSpanStyleOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_previewBorderRadius = value.previewBorderRadius;
-    Ark_Int32 value_previewBorderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_previewBorderRadius_type = runtimeType(value_previewBorderRadius);
-    valueSerializer.writeInt8(value_previewBorderRadius_type);
-    if ((value_previewBorderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_previewBorderRadius_value = value_previewBorderRadius.value;
-        Ark_Int32 value_previewBorderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_previewBorderRadius_value_type = value_previewBorderRadius_value.selector;
-        if ((value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0) || (value_previewBorderRadius_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_previewBorderRadius_value_0 = value_previewBorderRadius_value.value0;
-            Ark_Int32 value_previewBorderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_previewBorderRadius_value_0_type = value_previewBorderRadius_value_0.selector;
-            if (value_previewBorderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_previewBorderRadius_value_0_0 = value_previewBorderRadius_value_0.value0;
-                valueSerializer.writeString(value_previewBorderRadius_value_0_0);
-            }
-            else if (value_previewBorderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_previewBorderRadius_value_0_1 = value_previewBorderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_previewBorderRadius_value_0_1);
-            }
-            else if (value_previewBorderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_previewBorderRadius_value_0_2 = value_previewBorderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_previewBorderRadius_value_0_2);
-            }
-        }
-        else if (value_previewBorderRadius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_previewBorderRadius_value_1 = value_previewBorderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_1);
-        }
-        else if (value_previewBorderRadius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_previewBorderRadius_value_2 = value_previewBorderRadius_value.value2;
-            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_previewBorderRadius_value_2);
-        }
+    value.start = start_buf;
+    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number end_buf = {};
+    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_borderRadius = value.borderRadius;
-    Ark_Int32 value_borderRadius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_borderRadius_type = runtimeType(value_borderRadius);
-    valueSerializer.writeInt8(value_borderRadius_type);
-    if ((value_borderRadius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_borderRadius_value = value_borderRadius.value;
-        Ark_Int32 value_borderRadius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_borderRadius_value_type = value_borderRadius_value.selector;
-        if ((value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0) || (value_borderRadius_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_borderRadius_value_0 = value_borderRadius_value.value0;
-            Ark_Int32 value_borderRadius_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_borderRadius_value_0_type = value_borderRadius_value_0.selector;
-            if (value_borderRadius_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_borderRadius_value_0_0 = value_borderRadius_value_0.value0;
-                valueSerializer.writeString(value_borderRadius_value_0_0);
-            }
-            else if (value_borderRadius_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_borderRadius_value_0_1 = value_borderRadius_value_0.value1;
-                valueSerializer.writeNumber(value_borderRadius_value_0_1);
-            }
-            else if (value_borderRadius_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_borderRadius_value_0_2 = value_borderRadius_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_borderRadius_value_0_2);
-            }
-        }
-        else if (value_borderRadius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_borderRadius_value_1 = value_borderRadius_value.value1;
-            BorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_1);
-        }
-        else if (value_borderRadius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_borderRadius_value_2 = value_borderRadius_value.value2;
-            LocalizedBorderRadiuses_serializer::write(valueSerializer, value_borderRadius_value_2);
-        }
+    value.end = end_buf;
+    value.imageStyle = RichEditorImageSpanStyle_serializer::read(valueDeserializer);
+    return value;
+}
+inline void RichEditorUpdateTextSpanStyleOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorUpdateTextSpanStyleOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_start = value.start;
+    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
+    value_start_type = runtimeType(value_start);
+    valueSerializer.writeInt8(value_start_type);
+    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_start_value = value_start.value;
+        valueSerializer.writeNumber(value_start_value);
     }
-    const auto value_onAppear = value.onAppear;
-    Ark_Int32 value_onAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onAppear_type = runtimeType(value_onAppear);
-    valueSerializer.writeInt8(value_onAppear_type);
-    if ((value_onAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onAppear_value = value_onAppear.value;
-        valueSerializer.writeCallbackResource(value_onAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAppear_value.callSync));
+    const auto value_end = value.end;
+    Ark_Int32 value_end_type = INTEROP_RUNTIME_UNDEFINED;
+    value_end_type = runtimeType(value_end);
+    valueSerializer.writeInt8(value_end_type);
+    if ((value_end_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_end_value = value_end.value;
+        valueSerializer.writeNumber(value_end_value);
     }
-    const auto value_onDisappear = value.onDisappear;
-    Ark_Int32 value_onDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onDisappear_type = runtimeType(value_onDisappear);
-    valueSerializer.writeInt8(value_onDisappear_type);
-    if ((value_onDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onDisappear_value = value_onDisappear.value;
-        valueSerializer.writeCallbackResource(value_onDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDisappear_value.callSync));
+    const auto value_textStyle = value.textStyle;
+    RichEditorTextStyle_serializer::write(valueSerializer, value_textStyle);
+    const auto value_urlStyle = value.urlStyle;
+    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_urlStyle_type = runtimeType(value_urlStyle);
+    valueSerializer.writeInt8(value_urlStyle_type);
+    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_urlStyle_value = value_urlStyle.value;
+        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
     }
-    const auto value_aboutToAppear = value.aboutToAppear;
-    Ark_Int32 value_aboutToAppear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_aboutToAppear_type = runtimeType(value_aboutToAppear);
-    valueSerializer.writeInt8(value_aboutToAppear_type);
-    if ((value_aboutToAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_aboutToAppear_value = value_aboutToAppear.value;
-        valueSerializer.writeCallbackResource(value_aboutToAppear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToAppear_value.callSync));
+}
+inline Ark_RichEditorUpdateTextSpanStyleOptions RichEditorUpdateTextSpanStyleOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorUpdateTextSpanStyleOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_aboutToDisappear = value.aboutToDisappear;
-    Ark_Int32 value_aboutToDisappear_type = INTEROP_RUNTIME_UNDEFINED;
-    value_aboutToDisappear_type = runtimeType(value_aboutToDisappear);
-    valueSerializer.writeInt8(value_aboutToDisappear_type);
-    if ((value_aboutToDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_aboutToDisappear_value = value_aboutToDisappear.value;
-        valueSerializer.writeCallbackResource(value_aboutToDisappear_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_aboutToDisappear_value.callSync));
+    value.start = start_buf;
+    const auto end_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number end_buf = {};
+    end_buf.tag = end_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((end_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        end_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    const auto value_layoutRegionMargin = value.layoutRegionMargin;
-    Ark_Int32 value_layoutRegionMargin_type = INTEROP_RUNTIME_UNDEFINED;
-    value_layoutRegionMargin_type = runtimeType(value_layoutRegionMargin);
-    valueSerializer.writeInt8(value_layoutRegionMargin_type);
-    if ((value_layoutRegionMargin_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_layoutRegionMargin_value = value_layoutRegionMargin.value;
-        Padding_serializer::write(valueSerializer, value_layoutRegionMargin_value);
+    value.end = end_buf;
+    value.textStyle = RichEditorTextStyle_serializer::read(valueDeserializer);
+    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorUrlStyle urlStyle_buf = {};
+    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
     }
-    const auto value_previewAnimationOptions = value.previewAnimationOptions;
-    Ark_Int32 value_previewAnimationOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_previewAnimationOptions_type = runtimeType(value_previewAnimationOptions);
-    valueSerializer.writeInt8(value_previewAnimationOptions_type);
-    if ((value_previewAnimationOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_previewAnimationOptions_value = value_previewAnimationOptions.value;
-        ContextMenuAnimationOptions_serializer::write(valueSerializer, value_previewAnimationOptions_value);
+    value.urlStyle = urlStyle_buf;
+    return value;
+}
+inline void StyleOptions_serializer::write(SerializerBase& buffer, Ark_StyleOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_start = value.start;
+    Ark_Int32 value_start_type = INTEROP_RUNTIME_UNDEFINED;
+    value_start_type = runtimeType(value_start);
+    valueSerializer.writeInt8(value_start_type);
+    if ((value_start_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_start_value = value_start.value;
+        valueSerializer.writeNumber(value_start_value);
     }
-    const auto value_backgroundColor = value.backgroundColor;
-    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundColor_type = runtimeType(value_backgroundColor);
-    valueSerializer.writeInt8(value_backgroundColor_type);
-    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundColor_value = value_backgroundColor.value;
-        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_backgroundColor_value_type = value_backgroundColor_value.selector;
-        if (value_backgroundColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
-        }
-        else if (value_backgroundColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
-            valueSerializer.writeNumber(value_backgroundColor_value_1);
-        }
-        else if (value_backgroundColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
-            valueSerializer.writeString(value_backgroundColor_value_2);
-        }
-        else if (value_backgroundColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
-        }
+    const auto value_length = value.length;
+    Ark_Int32 value_length_type = INTEROP_RUNTIME_UNDEFINED;
+    value_length_type = runtimeType(value_length);
+    valueSerializer.writeInt8(value_length_type);
+    if ((value_length_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_length_value = value_length.value;
+        valueSerializer.writeNumber(value_length_value);
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
+    const auto value_styledKey = value.styledKey;
+    valueSerializer.writeInt32(static_cast<Ark_StyledStringKey>(value_styledKey));
+    const auto value_styledValue = value.styledValue;
+    Ark_Int32 value_styledValue_type = INTEROP_RUNTIME_UNDEFINED;
+    value_styledValue_type = value_styledValue.selector;
+    if (value_styledValue_type == 0) {
+        valueSerializer.writeInt8(0);
+        const auto value_styledValue_0 = value_styledValue.value0;
+        TextStyle_serializer::write(valueSerializer, value_styledValue_0);
     }
-    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
-    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
-    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
-    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
-        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
+    else if (value_styledValue_type == 1) {
+        valueSerializer.writeInt8(1);
+        const auto value_styledValue_1 = value_styledValue.value1;
+        DecorationStyle_serializer::write(valueSerializer, value_styledValue_1);
     }
-    const auto value_backgroundEffect = value.backgroundEffect;
-    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
-    valueSerializer.writeInt8(value_backgroundEffect_type);
-    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundEffect_value = value_backgroundEffect.value;
-        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
+    else if (value_styledValue_type == 2) {
+        valueSerializer.writeInt8(2);
+        const auto value_styledValue_2 = value_styledValue.value2;
+        BaselineOffsetStyle_serializer::write(valueSerializer, value_styledValue_2);
     }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    else if (value_styledValue_type == 3) {
+        valueSerializer.writeInt8(3);
+        const auto value_styledValue_3 = value_styledValue.value3;
+        LetterSpacingStyle_serializer::write(valueSerializer, value_styledValue_3);
     }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHoverMode_value = value_enableHoverMode.value;
-        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    else if (value_styledValue_type == 4) {
+        valueSerializer.writeInt8(4);
+        const auto value_styledValue_4 = value_styledValue.value4;
+        TextShadowStyle_serializer::write(valueSerializer, value_styledValue_4);
     }
-    const auto value_outlineColor = value.outlineColor;
-    Ark_Int32 value_outlineColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_outlineColor_type = runtimeType(value_outlineColor);
-    valueSerializer.writeInt8(value_outlineColor_type);
-    if ((value_outlineColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_outlineColor_value = value_outlineColor.value;
-        Ark_Int32 value_outlineColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_outlineColor_value_type = value_outlineColor_value.selector;
-        if ((value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0) || (value_outlineColor_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_outlineColor_value_0 = value_outlineColor_value.value0;
-            Ark_Int32 value_outlineColor_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_outlineColor_value_0_type = value_outlineColor_value_0.selector;
-            if (value_outlineColor_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_outlineColor_value_0_0 = value_outlineColor_value_0.value0;
-                valueSerializer.writeInt32(static_cast<Ark_Color>(value_outlineColor_value_0_0));
-            }
-            else if (value_outlineColor_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_outlineColor_value_0_1 = value_outlineColor_value_0.value1;
-                valueSerializer.writeNumber(value_outlineColor_value_0_1);
-            }
-            else if (value_outlineColor_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_outlineColor_value_0_2 = value_outlineColor_value_0.value2;
-                valueSerializer.writeString(value_outlineColor_value_0_2);
-            }
-            else if (value_outlineColor_value_0_type == 3) {
-                valueSerializer.writeInt8(3);
-                const auto value_outlineColor_value_0_3 = value_outlineColor_value_0.value3;
-                Resource_serializer::write(valueSerializer, value_outlineColor_value_0_3);
-            }
-        }
-        else if (value_outlineColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_outlineColor_value_1 = value_outlineColor_value.value1;
-            EdgeColors_serializer::write(valueSerializer, value_outlineColor_value_1);
-        }
+    else if (value_styledValue_type == 5) {
+        valueSerializer.writeInt8(5);
+        const auto value_styledValue_5 = value_styledValue.value5;
+        GestureStyle_serializer::write(valueSerializer, value_styledValue_5);
     }
-    const auto value_outlineWidth = value.outlineWidth;
-    Ark_Int32 value_outlineWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_outlineWidth_type = runtimeType(value_outlineWidth);
-    valueSerializer.writeInt8(value_outlineWidth_type);
-    if ((value_outlineWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_outlineWidth_value = value_outlineWidth.value;
-        Ark_Int32 value_outlineWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_outlineWidth_value_type = value_outlineWidth_value.selector;
-        if ((value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0) || (value_outlineWidth_value_type == 0)) {
-            valueSerializer.writeInt8(0);
-            const auto value_outlineWidth_value_0 = value_outlineWidth_value.value0;
-            Ark_Int32 value_outlineWidth_value_0_type = INTEROP_RUNTIME_UNDEFINED;
-            value_outlineWidth_value_0_type = value_outlineWidth_value_0.selector;
-            if (value_outlineWidth_value_0_type == 0) {
-                valueSerializer.writeInt8(0);
-                const auto value_outlineWidth_value_0_0 = value_outlineWidth_value_0.value0;
-                valueSerializer.writeString(value_outlineWidth_value_0_0);
-            }
-            else if (value_outlineWidth_value_0_type == 1) {
-                valueSerializer.writeInt8(1);
-                const auto value_outlineWidth_value_0_1 = value_outlineWidth_value_0.value1;
-                valueSerializer.writeNumber(value_outlineWidth_value_0_1);
-            }
-            else if (value_outlineWidth_value_0_type == 2) {
-                valueSerializer.writeInt8(2);
-                const auto value_outlineWidth_value_0_2 = value_outlineWidth_value_0.value2;
-                Resource_serializer::write(valueSerializer, value_outlineWidth_value_0_2);
-            }
-        }
-        else if (value_outlineWidth_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_outlineWidth_value_1 = value_outlineWidth_value.value1;
-            EdgeOutlineWidths_serializer::write(valueSerializer, value_outlineWidth_value_1);
-        }
+    else if (value_styledValue_type == 6) {
+        valueSerializer.writeInt8(6);
+        const auto value_styledValue_6 = value_styledValue.value6;
+        ImageAttachment_serializer::write(valueSerializer, value_styledValue_6);
     }
-    const auto value_hapticFeedbackMode = value.hapticFeedbackMode;
-    Ark_Int32 value_hapticFeedbackMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_hapticFeedbackMode_type = runtimeType(value_hapticFeedbackMode);
-    valueSerializer.writeInt8(value_hapticFeedbackMode_type);
-    if ((value_hapticFeedbackMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_hapticFeedbackMode_value = value_hapticFeedbackMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_HapticFeedbackMode>(value_hapticFeedbackMode_value));
+    else if (value_styledValue_type == 7) {
+        valueSerializer.writeInt8(7);
+        const auto value_styledValue_7 = value_styledValue.value7;
+        ParagraphStyle_serializer::write(valueSerializer, value_styledValue_7);
     }
-    const auto value_title = value.title;
-    Ark_Int32 value_title_type = INTEROP_RUNTIME_UNDEFINED;
-    value_title_type = runtimeType(value_title);
-    valueSerializer.writeInt8(value_title_type);
-    if ((value_title_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_title_value = value_title.value;
-        Ark_Int32 value_title_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_title_value_type = value_title_value.selector;
-        if (value_title_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_title_value_0 = value_title_value.value0;
-            valueSerializer.writeString(value_title_value_0);
-        }
-        else if (value_title_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_title_value_1 = value_title_value.value1;
-            Resource_serializer::write(valueSerializer, value_title_value_1);
-        }
+    else if (value_styledValue_type == 8) {
+        valueSerializer.writeInt8(8);
+        const auto value_styledValue_8 = value_styledValue.value8;
+        LineHeightStyle_serializer::write(valueSerializer, value_styledValue_8);
     }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
+    else if (value_styledValue_type == 9) {
+        valueSerializer.writeInt8(9);
+        const auto value_styledValue_9 = value_styledValue.value9;
+        UrlStyle_serializer::write(valueSerializer, value_styledValue_9);
+    }
+    else if (value_styledValue_type == 10) {
+        valueSerializer.writeInt8(10);
+        const auto value_styledValue_10 = value_styledValue.value10;
+        CustomSpan_serializer::write(valueSerializer, value_styledValue_10);
+    }
+    else if (value_styledValue_type == 11) {
+        valueSerializer.writeInt8(11);
+        const auto value_styledValue_11 = value_styledValue.value11;
+        UserDataSpan_serializer::write(valueSerializer, value_styledValue_11);
+    }
+    else if (value_styledValue_type == 12) {
+        valueSerializer.writeInt8(12);
+        const auto value_styledValue_12 = value_styledValue.value12;
+        BackgroundColorStyle_serializer::write(valueSerializer, value_styledValue_12);
     }
 }
-inline Ark_MenuOptions MenuOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_StyleOptions StyleOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_MenuOptions value = {};
+    Ark_StyleOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto start_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number start_buf = {};
+    start_buf.tag = start_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((start_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
+        start_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.offset = offset_buf;
-    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Placement placement_buf = {};
-    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.start = start_buf;
+    const auto length_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number length_buf = {};
+    length_buf.tag = length_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((length_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
+        length_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.placement = placement_buf;
-    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableArrow_buf = {};
-    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableArrow_buf.value = valueDeserializer.readBoolean();
+    value.length = length_buf;
+    value.styledKey = static_cast<Ark_StyledStringKey>(valueDeserializer.readInt32());
+    const Ark_Int8 styledValue_buf_selector = valueDeserializer.readInt8();
+    Ark_StyledStringValue styledValue_buf = {};
+    styledValue_buf.selector = styledValue_buf_selector;
+    if (styledValue_buf_selector == 0) {
+        styledValue_buf.selector = 0;
+        styledValue_buf.value0 = static_cast<Ark_TextStyle>(TextStyle_serializer::read(valueDeserializer));
     }
-    value.enableArrow = enableArrow_buf;
-    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length arrowOffset_buf = {};
-    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
-        Ark_Length arrowOffset_buf_ = {};
-        arrowOffset_buf_.selector = arrowOffset_buf__selector;
-        if (arrowOffset_buf__selector == 0) {
-            arrowOffset_buf_.selector = 0;
-            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowOffset_buf__selector == 1) {
-            arrowOffset_buf_.selector = 1;
-            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowOffset_buf__selector == 2) {
-            arrowOffset_buf_.selector = 2;
-            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
-        }
-        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
+    else if (styledValue_buf_selector == 1) {
+        styledValue_buf.selector = 1;
+        styledValue_buf.value1 = static_cast<Ark_DecorationStyle>(DecorationStyle_serializer::read(valueDeserializer));
     }
-    value.arrowOffset = arrowOffset_buf;
-    const auto preview_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_MenuPreviewMode_CustomBuilder preview_buf = {};
-    preview_buf.tag = preview_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((preview_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 preview_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_MenuPreviewMode_CustomBuilder preview_buf_ = {};
-        preview_buf_.selector = preview_buf__selector;
-        if (preview_buf__selector == 0) {
-            preview_buf_.selector = 0;
-            preview_buf_.value0 = static_cast<Ark_MenuPreviewMode>(valueDeserializer.readInt32());
-        }
-        else if (preview_buf__selector == 1) {
-            preview_buf_.selector = 1;
-            preview_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_CustomNodeBuilder)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_NativePointer parentNode, const Callback_Pointer_Void continuation)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_CustomNodeBuilder))))};
-        }
-        else {
-            INTEROP_FATAL("One of the branches for preview_buf_ has to be chosen through deserialisation.");
-        }
-        preview_buf.value = static_cast<Ark_Union_MenuPreviewMode_CustomBuilder>(preview_buf_);
+    else if (styledValue_buf_selector == 2) {
+        styledValue_buf.selector = 2;
+        styledValue_buf.value2 = static_cast<Ark_BaselineOffsetStyle>(BaselineOffsetStyle_serializer::read(valueDeserializer));
     }
-    value.preview = preview_buf;
-    const auto previewBorderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BorderRadiusType previewBorderRadius_buf = {};
-    previewBorderRadius_buf.tag = previewBorderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((previewBorderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 previewBorderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_BorderRadiusType previewBorderRadius_buf_ = {};
-        previewBorderRadius_buf_.selector = previewBorderRadius_buf__selector;
-        if (previewBorderRadius_buf__selector == 0) {
-            previewBorderRadius_buf_.selector = 0;
-            const Ark_Int8 previewBorderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length previewBorderRadius_buf__u = {};
-            previewBorderRadius_buf__u.selector = previewBorderRadius_buf__u_selector;
-            if (previewBorderRadius_buf__u_selector == 0) {
-                previewBorderRadius_buf__u.selector = 0;
-                previewBorderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (previewBorderRadius_buf__u_selector == 1) {
-                previewBorderRadius_buf__u.selector = 1;
-                previewBorderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (previewBorderRadius_buf__u_selector == 2) {
-                previewBorderRadius_buf__u.selector = 2;
-                previewBorderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for previewBorderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            previewBorderRadius_buf_.value0 = static_cast<Ark_Length>(previewBorderRadius_buf__u);
-        }
-        else if (previewBorderRadius_buf__selector == 1) {
-            previewBorderRadius_buf_.selector = 1;
-            previewBorderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else if (previewBorderRadius_buf__selector == 2) {
-            previewBorderRadius_buf_.selector = 2;
-            previewBorderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for previewBorderRadius_buf_ has to be chosen through deserialisation.");
-        }
-        previewBorderRadius_buf.value = static_cast<Ark_BorderRadiusType>(previewBorderRadius_buf_);
+    else if (styledValue_buf_selector == 3) {
+        styledValue_buf.selector = 3;
+        styledValue_buf.value3 = static_cast<Ark_LetterSpacingStyle>(LetterSpacingStyle_serializer::read(valueDeserializer));
     }
-    value.previewBorderRadius = previewBorderRadius_buf;
-    const auto borderRadius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf = {};
-    borderRadius_buf.tag = borderRadius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((borderRadius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 borderRadius_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius_buf_ = {};
-        borderRadius_buf_.selector = borderRadius_buf__selector;
-        if (borderRadius_buf__selector == 0) {
-            borderRadius_buf_.selector = 0;
-            const Ark_Int8 borderRadius_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Length borderRadius_buf__u = {};
-            borderRadius_buf__u.selector = borderRadius_buf__u_selector;
-            if (borderRadius_buf__u_selector == 0) {
-                borderRadius_buf__u.selector = 0;
-                borderRadius_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (borderRadius_buf__u_selector == 1) {
-                borderRadius_buf__u.selector = 1;
-                borderRadius_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (borderRadius_buf__u_selector == 2) {
-                borderRadius_buf__u.selector = 2;
-                borderRadius_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for borderRadius_buf__u has to be chosen through deserialisation.");
-            }
-            borderRadius_buf_.value0 = static_cast<Ark_Length>(borderRadius_buf__u);
-        }
-        else if (borderRadius_buf__selector == 1) {
-            borderRadius_buf_.selector = 1;
-            borderRadius_buf_.value1 = BorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else if (borderRadius_buf__selector == 2) {
-            borderRadius_buf_.selector = 2;
-            borderRadius_buf_.value2 = LocalizedBorderRadiuses_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for borderRadius_buf_ has to be chosen through deserialisation.");
-        }
-        borderRadius_buf.value = static_cast<Ark_Union_Length_BorderRadiuses_LocalizedBorderRadiuses>(borderRadius_buf_);
+    else if (styledValue_buf_selector == 4) {
+        styledValue_buf.selector = 4;
+        styledValue_buf.value4 = static_cast<Ark_TextShadowStyle>(TextShadowStyle_serializer::read(valueDeserializer));
     }
-    value.borderRadius = borderRadius_buf;
-    const auto onAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onAppear_buf = {};
-    onAppear_buf.tag = onAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    else if (styledValue_buf_selector == 5) {
+        styledValue_buf.selector = 5;
+        styledValue_buf.value5 = static_cast<Ark_GestureStyle>(GestureStyle_serializer::read(valueDeserializer));
     }
-    value.onAppear = onAppear_buf;
-    const auto onDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void onDisappear_buf = {};
-    onDisappear_buf.tag = onDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    else if (styledValue_buf_selector == 6) {
+        styledValue_buf.selector = 6;
+        styledValue_buf.value6 = static_cast<Ark_ImageAttachment>(ImageAttachment_serializer::read(valueDeserializer));
     }
-    value.onDisappear = onDisappear_buf;
-    const auto aboutToAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void aboutToAppear_buf = {};
-    aboutToAppear_buf.tag = aboutToAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((aboutToAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        aboutToAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    else if (styledValue_buf_selector == 7) {
+        styledValue_buf.selector = 7;
+        styledValue_buf.value7 = static_cast<Ark_ParagraphStyle>(ParagraphStyle_serializer::read(valueDeserializer));
     }
-    value.aboutToAppear = aboutToAppear_buf;
-    const auto aboutToDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Callback_Void aboutToDisappear_buf = {};
-    aboutToDisappear_buf.tag = aboutToDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((aboutToDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        aboutToDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    else if (styledValue_buf_selector == 8) {
+        styledValue_buf.selector = 8;
+        styledValue_buf.value8 = static_cast<Ark_LineHeightStyle>(LineHeightStyle_serializer::read(valueDeserializer));
     }
-    value.aboutToDisappear = aboutToDisappear_buf;
-    const auto layoutRegionMargin_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Padding layoutRegionMargin_buf = {};
-    layoutRegionMargin_buf.tag = layoutRegionMargin_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((layoutRegionMargin_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        layoutRegionMargin_buf.value = Padding_serializer::read(valueDeserializer);
+    else if (styledValue_buf_selector == 9) {
+        styledValue_buf.selector = 9;
+        styledValue_buf.value9 = static_cast<Ark_UrlStyle>(UrlStyle_serializer::read(valueDeserializer));
     }
-    value.layoutRegionMargin = layoutRegionMargin_buf;
-    const auto previewAnimationOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ContextMenuAnimationOptions previewAnimationOptions_buf = {};
-    previewAnimationOptions_buf.tag = previewAnimationOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((previewAnimationOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        previewAnimationOptions_buf.value = ContextMenuAnimationOptions_serializer::read(valueDeserializer);
+    else if (styledValue_buf_selector == 10) {
+        styledValue_buf.selector = 10;
+        styledValue_buf.value10 = static_cast<Ark_CustomSpan>(CustomSpan_serializer::read(valueDeserializer));
     }
-    value.previewAnimationOptions = previewAnimationOptions_buf;
-    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor backgroundColor_buf = {};
-    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor backgroundColor_buf_ = {};
-        backgroundColor_buf_.selector = backgroundColor_buf__selector;
-        if (backgroundColor_buf__selector == 0) {
-            backgroundColor_buf_.selector = 0;
-            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (backgroundColor_buf__selector == 1) {
-            backgroundColor_buf_.selector = 1;
-            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (backgroundColor_buf__selector == 2) {
-            backgroundColor_buf_.selector = 2;
-            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
+    else if (styledValue_buf_selector == 11) {
+        styledValue_buf.selector = 11;
+        styledValue_buf.value11 = static_cast<Ark_UserDataSpan>(UserDataSpan_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 12) {
+        styledValue_buf.selector = 12;
+        styledValue_buf.value12 = static_cast<Ark_BackgroundColorStyle>(BackgroundColorStyle_serializer::read(valueDeserializer));
+    }
+    else {
+        INTEROP_FATAL("One of the branches for styledValue_buf has to be chosen through deserialisation.");
+    }
+    value.styledValue = static_cast<Ark_StyledStringValue>(styledValue_buf);
+    return value;
+}
+inline void SubTabBarStyle_serializer::write(SerializerBase& buffer, Ark_SubTabBarStyle value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value__content = value._content;
+    Ark_Int32 value__content_type = INTEROP_RUNTIME_UNDEFINED;
+    value__content_type = runtimeType(value__content);
+    valueSerializer.writeInt8(value__content_type);
+    if ((value__content_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__content_value = value__content.value;
+        Ark_Int32 value__content_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__content_value_type = value__content_value.selector;
+        if (value__content_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value__content_value_0 = value__content_value.value0;
+            valueSerializer.writeString(value__content_value_0);
         }
-        else if (backgroundColor_buf__selector == 3) {
-            backgroundColor_buf_.selector = 3;
-            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
+        else if (value__content_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value__content_value_1 = value__content_value.value1;
+            Resource_serializer::write(valueSerializer, value__content_value_1);
         }
-        else {
-            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
+        else if (value__content_value_type == 2) {
+            valueSerializer.writeInt8(2);
+            const auto value__content_value_2 = value__content_value.value2;
+            ComponentContent_serializer::write(valueSerializer, value__content_value_2);
         }
-        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
-    }
-    value.backgroundColor = backgroundColor_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
     }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
-    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
+    const auto value__indicator = value._indicator;
+    Ark_Int32 value__indicator_type = INTEROP_RUNTIME_UNDEFINED;
+    value__indicator_type = runtimeType(value__indicator);
+    valueSerializer.writeInt8(value__indicator_type);
+    if ((value__indicator_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__indicator_value = value__indicator.value;
+        SubTabBarIndicatorStyle_serializer::write(valueSerializer, value__indicator_value);
     }
-    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
-    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
-    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
+    const auto value__selectedMode = value._selectedMode;
+    Ark_Int32 value__selectedMode_type = INTEROP_RUNTIME_UNDEFINED;
+    value__selectedMode_type = runtimeType(value__selectedMode);
+    valueSerializer.writeInt8(value__selectedMode_type);
+    if ((value__selectedMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__selectedMode_value = value__selectedMode.value;
+        valueSerializer.writeInt32(static_cast<Ark_SelectedMode>(value__selectedMode_value));
     }
-    value.backgroundEffect = backgroundEffect_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+    const auto value__board = value._board;
+    Ark_Int32 value__board_type = INTEROP_RUNTIME_UNDEFINED;
+    value__board_type = runtimeType(value__board);
+    valueSerializer.writeInt8(value__board_type);
+    if ((value__board_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__board_value = value__board.value;
+        BoardStyle_serializer::write(valueSerializer, value__board_value);
     }
-    value.transition = transition_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+    const auto value__labelStyle = value._labelStyle;
+    Ark_Int32 value__labelStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value__labelStyle_type = runtimeType(value__labelStyle);
+    valueSerializer.writeInt8(value__labelStyle_type);
+    if ((value__labelStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__labelStyle_value = value__labelStyle.value;
+        TabBarLabelStyle_serializer::write(valueSerializer, value__labelStyle_value);
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto outlineColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ResourceColor_EdgeColors outlineColor_buf = {};
-    outlineColor_buf.tag = outlineColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((outlineColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 outlineColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ResourceColor_EdgeColors outlineColor_buf_ = {};
-        outlineColor_buf_.selector = outlineColor_buf__selector;
-        if (outlineColor_buf__selector == 0) {
-            outlineColor_buf_.selector = 0;
-            const Ark_Int8 outlineColor_buf__u_selector = valueDeserializer.readInt8();
-            Ark_ResourceColor outlineColor_buf__u = {};
-            outlineColor_buf__u.selector = outlineColor_buf__u_selector;
-            if (outlineColor_buf__u_selector == 0) {
-                outlineColor_buf__u.selector = 0;
-                outlineColor_buf__u.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-            }
-            else if (outlineColor_buf__u_selector == 1) {
-                outlineColor_buf__u.selector = 1;
-                outlineColor_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (outlineColor_buf__u_selector == 2) {
-                outlineColor_buf__u.selector = 2;
-                outlineColor_buf__u.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (outlineColor_buf__u_selector == 3) {
-                outlineColor_buf__u.selector = 3;
-                outlineColor_buf__u.value3 = Resource_serializer::read(valueDeserializer);
+    const auto value__padding = value._padding;
+    Ark_Int32 value__padding_type = INTEROP_RUNTIME_UNDEFINED;
+    value__padding_type = runtimeType(value__padding);
+    valueSerializer.writeInt8(value__padding_type);
+    if ((value__padding_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__padding_value = value__padding.value;
+        Ark_Int32 value__padding_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value__padding_value_type = value__padding_value.selector;
+        if ((value__padding_value_type == 0) || (value__padding_value_type == 0) || (value__padding_value_type == 0) || (value__padding_value_type == 0)) {
+            valueSerializer.writeInt8(0);
+            const auto value__padding_value_0 = value__padding_value.value0;
+            Ark_Int32 value__padding_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value__padding_value_0_type = value__padding_value_0.selector;
+            if (value__padding_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value__padding_value_0_0 = value__padding_value_0.value0;
+                Padding_serializer::write(valueSerializer, value__padding_value_0_0);
             }
-            else {
-                INTEROP_FATAL("One of the branches for outlineColor_buf__u has to be chosen through deserialisation.");
+            else if ((value__padding_value_0_type == 1) || (value__padding_value_0_type == 1) || (value__padding_value_0_type == 1)) {
+                valueSerializer.writeInt8(1);
+                const auto value__padding_value_0_1 = value__padding_value_0.value1;
+                Ark_Int32 value__padding_value_0_1_type = INTEROP_RUNTIME_UNDEFINED;
+                value__padding_value_0_1_type = value__padding_value_0_1.selector;
+                if (value__padding_value_0_1_type == 0) {
+                    valueSerializer.writeInt8(0);
+                    const auto value__padding_value_0_1_0 = value__padding_value_0_1.value0;
+                    valueSerializer.writeString(value__padding_value_0_1_0);
+                }
+                else if (value__padding_value_0_1_type == 1) {
+                    valueSerializer.writeInt8(1);
+                    const auto value__padding_value_0_1_1 = value__padding_value_0_1.value1;
+                    valueSerializer.writeNumber(value__padding_value_0_1_1);
+                }
+                else if (value__padding_value_0_1_type == 2) {
+                    valueSerializer.writeInt8(2);
+                    const auto value__padding_value_0_1_2 = value__padding_value_0_1.value2;
+                    Resource_serializer::write(valueSerializer, value__padding_value_0_1_2);
+                }
             }
-            outlineColor_buf_.value0 = static_cast<Ark_ResourceColor>(outlineColor_buf__u);
-        }
-        else if (outlineColor_buf__selector == 1) {
-            outlineColor_buf_.selector = 1;
-            outlineColor_buf_.value1 = EdgeColors_serializer::read(valueDeserializer);
         }
-        else {
-            INTEROP_FATAL("One of the branches for outlineColor_buf_ has to be chosen through deserialisation.");
+        else if (value__padding_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value__padding_value_1 = value__padding_value.value1;
+            LocalizedPadding_serializer::write(valueSerializer, value__padding_value_1);
         }
-        outlineColor_buf.value = static_cast<Ark_Union_ResourceColor_EdgeColors>(outlineColor_buf_);
     }
-    value.outlineColor = outlineColor_buf;
-    const auto outlineWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth_buf = {};
-    outlineWidth_buf.tag = outlineWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((outlineWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 outlineWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Dimension_EdgeOutlineWidths outlineWidth_buf_ = {};
-        outlineWidth_buf_.selector = outlineWidth_buf__selector;
-        if (outlineWidth_buf__selector == 0) {
-            outlineWidth_buf_.selector = 0;
-            const Ark_Int8 outlineWidth_buf__u_selector = valueDeserializer.readInt8();
-            Ark_Dimension outlineWidth_buf__u = {};
-            outlineWidth_buf__u.selector = outlineWidth_buf__u_selector;
-            if (outlineWidth_buf__u_selector == 0) {
-                outlineWidth_buf__u.selector = 0;
-                outlineWidth_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-            }
-            else if (outlineWidth_buf__u_selector == 1) {
-                outlineWidth_buf__u.selector = 1;
-                outlineWidth_buf__u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-            }
-            else if (outlineWidth_buf__u_selector == 2) {
-                outlineWidth_buf__u.selector = 2;
-                outlineWidth_buf__u.value2 = Resource_serializer::read(valueDeserializer);
-            }
-            else {
-                INTEROP_FATAL("One of the branches for outlineWidth_buf__u has to be chosen through deserialisation.");
-            }
-            outlineWidth_buf_.value0 = static_cast<Ark_Dimension>(outlineWidth_buf__u);
+    const auto value__id = value._id;
+    Ark_Int32 value__id_type = INTEROP_RUNTIME_UNDEFINED;
+    value__id_type = runtimeType(value__id);
+    valueSerializer.writeInt8(value__id_type);
+    if ((value__id_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value__id_value = value__id.value;
+        valueSerializer.writeString(value__id_value);
+    }
+}
+inline Ark_SubTabBarStyle SubTabBarStyle_serializer::read(DeserializerBase& buffer)
+{
+    Ark_SubTabBarStyle value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    const auto _content_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_String_Resource_ComponentContent _content_buf = {};
+    _content_buf.tag = _content_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_content_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 _content_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_String_Resource_ComponentContent _content_buf_ = {};
+        _content_buf_.selector = _content_buf__selector;
+        if (_content_buf__selector == 0) {
+            _content_buf_.selector = 0;
+            _content_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (outlineWidth_buf__selector == 1) {
-            outlineWidth_buf_.selector = 1;
-            outlineWidth_buf_.value1 = EdgeOutlineWidths_serializer::read(valueDeserializer);
+        else if (_content_buf__selector == 1) {
+            _content_buf_.selector = 1;
+            _content_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        }
+        else if (_content_buf__selector == 2) {
+            _content_buf_.selector = 2;
+            _content_buf_.value2 = static_cast<Ark_ComponentContent>(ComponentContent_serializer::read(valueDeserializer));
         }
         else {
-            INTEROP_FATAL("One of the branches for outlineWidth_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _content_buf_ has to be chosen through deserialisation.");
         }
-        outlineWidth_buf.value = static_cast<Ark_Union_Dimension_EdgeOutlineWidths>(outlineWidth_buf_);
+        _content_buf.value = static_cast<Ark_Union_String_Resource_ComponentContent>(_content_buf_);
     }
-    value.outlineWidth = outlineWidth_buf;
-    const auto hapticFeedbackMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_HapticFeedbackMode hapticFeedbackMode_buf = {};
-    hapticFeedbackMode_buf.tag = hapticFeedbackMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((hapticFeedbackMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._content = _content_buf;
+    const auto _indicator_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SubTabBarIndicatorStyle _indicator_buf = {};
+    _indicator_buf.tag = _indicator_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_indicator_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        hapticFeedbackMode_buf.value = static_cast<Ark_HapticFeedbackMode>(valueDeserializer.readInt32());
+        _indicator_buf.value = SubTabBarIndicatorStyle_serializer::read(valueDeserializer);
     }
-    value.hapticFeedbackMode = hapticFeedbackMode_buf;
-    const auto title_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceStr title_buf = {};
-    title_buf.tag = title_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((title_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._indicator = _indicator_buf;
+    const auto _selectedMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_SelectedMode _selectedMode_buf = {};
+    _selectedMode_buf.tag = _selectedMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_selectedMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 title_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceStr title_buf_ = {};
-        title_buf_.selector = title_buf__selector;
-        if (title_buf__selector == 0) {
-            title_buf_.selector = 0;
-            title_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+        _selectedMode_buf.value = static_cast<Ark_SelectedMode>(valueDeserializer.readInt32());
+    }
+    value._selectedMode = _selectedMode_buf;
+    const auto _board_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BoardStyle _board_buf = {};
+    _board_buf.tag = _board_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_board_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _board_buf.value = BoardStyle_serializer::read(valueDeserializer);
+    }
+    value._board = _board_buf;
+    const auto _labelStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TabBarLabelStyle _labelStyle_buf = {};
+    _labelStyle_buf.tag = _labelStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_labelStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        _labelStyle_buf.value = TabBarLabelStyle_serializer::read(valueDeserializer);
+    }
+    value._labelStyle = _labelStyle_buf;
+    const auto _padding_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Union_Padding_Dimension_LocalizedPadding _padding_buf = {};
+    _padding_buf.tag = _padding_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_padding_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 _padding_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Union_Padding_Dimension_LocalizedPadding _padding_buf_ = {};
+        _padding_buf_.selector = _padding_buf__selector;
+        if (_padding_buf__selector == 0) {
+            _padding_buf_.selector = 0;
+            const Ark_Int8 _padding_buf__u_selector = valueDeserializer.readInt8();
+            Ark_Union_Padding_Dimension _padding_buf__u = {};
+            _padding_buf__u.selector = _padding_buf__u_selector;
+            if (_padding_buf__u_selector == 0) {
+                _padding_buf__u.selector = 0;
+                _padding_buf__u.value0 = Padding_serializer::read(valueDeserializer);
+            }
+            else if (_padding_buf__u_selector == 1) {
+                _padding_buf__u.selector = 1;
+                const Ark_Int8 _padding_buf__u_u_selector = valueDeserializer.readInt8();
+                Ark_Dimension _padding_buf__u_u = {};
+                _padding_buf__u_u.selector = _padding_buf__u_u_selector;
+                if (_padding_buf__u_u_selector == 0) {
+                    _padding_buf__u_u.selector = 0;
+                    _padding_buf__u_u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+                }
+                else if (_padding_buf__u_u_selector == 1) {
+                    _padding_buf__u_u.selector = 1;
+                    _padding_buf__u_u.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+                }
+                else if (_padding_buf__u_u_selector == 2) {
+                    _padding_buf__u_u.selector = 2;
+                    _padding_buf__u_u.value2 = Resource_serializer::read(valueDeserializer);
+                }
+                else {
+                    INTEROP_FATAL("One of the branches for _padding_buf__u_u has to be chosen through deserialisation.");
+                }
+                _padding_buf__u.value1 = static_cast<Ark_Dimension>(_padding_buf__u_u);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for _padding_buf__u has to be chosen through deserialisation.");
+            }
+            _padding_buf_.value0 = static_cast<Ark_Union_Padding_Dimension>(_padding_buf__u);
         }
-        else if (title_buf__selector == 1) {
-            title_buf_.selector = 1;
-            title_buf_.value1 = Resource_serializer::read(valueDeserializer);
+        else if (_padding_buf__selector == 1) {
+            _padding_buf_.selector = 1;
+            _padding_buf_.value1 = LocalizedPadding_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for title_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for _padding_buf_ has to be chosen through deserialisation.");
         }
-        title_buf.value = static_cast<Ark_ResourceStr>(title_buf_);
+        _padding_buf.value = static_cast<Ark_Union_Union_Padding_Dimension_LocalizedPadding>(_padding_buf_);
     }
-    value.title = title_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value._padding = _padding_buf;
+    const auto _id_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String _id_buf = {};
+    _id_buf.tag = _id_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((_id_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+        _id_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.showInSubWindow = showInSubWindow_buf;
+    value._id = _id_buf;
     return value;
 }
-inline void PopupCommonOptions_serializer::write(SerializerBase& buffer, Ark_PopupCommonOptions value)
+inline void TextPickerDialogOptions_serializer::write(SerializerBase& buffer, Ark_TextPickerDialogOptions value)
 {
     SerializerBase& valueSerializer = buffer;
-    const auto value_placement = value.placement;
-    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placement_type = runtimeType(value_placement);
-    valueSerializer.writeInt8(value_placement_type);
-    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placement_value = value_placement.value;
-        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
-    }
-    const auto value_popupColor = value.popupColor;
-    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_popupColor_type = runtimeType(value_popupColor);
-    valueSerializer.writeInt8(value_popupColor_type);
-    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_popupColor_value = value_popupColor.value;
-        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_popupColor_value_type = value_popupColor_value.selector;
-        if (value_popupColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_popupColor_value_0 = value_popupColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
-        }
-        else if (value_popupColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_popupColor_value_1 = value_popupColor_value.value1;
-            valueSerializer.writeNumber(value_popupColor_value_1);
-        }
-        else if (value_popupColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_popupColor_value_2 = value_popupColor_value.value2;
-            valueSerializer.writeString(value_popupColor_value_2);
+    const auto value_range = value.range;
+    Ark_Int32 value_range_type = INTEROP_RUNTIME_UNDEFINED;
+    value_range_type = value_range.selector;
+    if (value_range_type == 0) {
+        valueSerializer.writeInt8(0);
+        const auto value_range_0 = value_range.value0;
+        valueSerializer.writeInt32(value_range_0.length);
+        for (int value_range_0_counter_i = 0; value_range_0_counter_i < value_range_0.length; value_range_0_counter_i++) {
+            const Ark_String value_range_0_element = value_range_0.array[value_range_0_counter_i];
+            valueSerializer.writeString(value_range_0_element);
         }
-        else if (value_popupColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_popupColor_value_3 = value_popupColor_value.value3;
-            Resource_serializer::write(valueSerializer, value_popupColor_value_3);
+    }
+    else if (value_range_type == 1) {
+        valueSerializer.writeInt8(1);
+        const auto value_range_1 = value_range.value1;
+        valueSerializer.writeInt32(value_range_1.length);
+        for (int value_range_1_counter_i = 0; value_range_1_counter_i < value_range_1.length; value_range_1_counter_i++) {
+            const Array_String value_range_1_element = value_range_1.array[value_range_1_counter_i];
+            valueSerializer.writeInt32(value_range_1_element.length);
+            for (int value_range_1_element_counter_i = 0; value_range_1_element_counter_i < value_range_1_element.length; value_range_1_element_counter_i++) {
+                const Ark_String value_range_1_element_element = value_range_1_element.array[value_range_1_element_counter_i];
+                valueSerializer.writeString(value_range_1_element_element);
+            }
         }
     }
-    const auto value_enableArrow = value.enableArrow;
-    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableArrow_type = runtimeType(value_enableArrow);
-    valueSerializer.writeInt8(value_enableArrow_type);
-    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableArrow_value = value_enableArrow.value;
-        valueSerializer.writeBoolean(value_enableArrow_value);
+    else if (value_range_type == 2) {
+        valueSerializer.writeInt8(2);
+        const auto value_range_2 = value_range.value2;
+        Resource_serializer::write(valueSerializer, value_range_2);
     }
-    const auto value_autoCancel = value.autoCancel;
-    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_autoCancel_type = runtimeType(value_autoCancel);
-    valueSerializer.writeInt8(value_autoCancel_type);
-    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_autoCancel_value = value_autoCancel.value;
-        valueSerializer.writeBoolean(value_autoCancel_value);
+    else if (value_range_type == 3) {
+        valueSerializer.writeInt8(3);
+        const auto value_range_3 = value_range.value3;
+        valueSerializer.writeInt32(value_range_3.length);
+        for (int value_range_3_counter_i = 0; value_range_3_counter_i < value_range_3.length; value_range_3_counter_i++) {
+            const Ark_TextPickerRangeContent value_range_3_element = value_range_3.array[value_range_3_counter_i];
+            TextPickerRangeContent_serializer::write(valueSerializer, value_range_3_element);
+        }
     }
-    const auto value_onStateChange = value.onStateChange;
-    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onStateChange_type = runtimeType(value_onStateChange);
-    valueSerializer.writeInt8(value_onStateChange_type);
-    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onStateChange_value = value_onStateChange.value;
-        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
+    else if (value_range_type == 4) {
+        valueSerializer.writeInt8(4);
+        const auto value_range_4 = value_range.value4;
+        valueSerializer.writeInt32(value_range_4.length);
+        for (int value_range_4_counter_i = 0; value_range_4_counter_i < value_range_4.length; value_range_4_counter_i++) {
+            const Ark_TextCascadePickerRangeContent value_range_4_element = value_range_4.array[value_range_4_counter_i];
+            TextCascadePickerRangeContent_serializer::write(valueSerializer, value_range_4_element);
+        }
     }
-    const auto value_arrowOffset = value.arrowOffset;
-    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowOffset_type = runtimeType(value_arrowOffset);
-    valueSerializer.writeInt8(value_arrowOffset_type);
-    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowOffset_value = value_arrowOffset.value;
-        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowOffset_value_type = value_arrowOffset_value.selector;
-        if (value_arrowOffset_value_type == 0) {
+    const auto value_value = value.value;
+    Ark_Int32 value_value_type = INTEROP_RUNTIME_UNDEFINED;
+    value_value_type = runtimeType(value_value);
+    valueSerializer.writeInt8(value_value_type);
+    if ((value_value_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_value_value = value_value.value;
+        Ark_Int32 value_value_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_value_value_type = value_value_value.selector;
+        if ((value_value_value_type == 0) || (value_value_value_type == 0)) {
             valueSerializer.writeInt8(0);
-            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
-            valueSerializer.writeString(value_arrowOffset_value_0);
+            const auto value_value_value_0 = value_value_value.value0;
+            Ark_Int32 value_value_value_0_type = INTEROP_RUNTIME_UNDEFINED;
+            value_value_value_0_type = value_value_value_0.selector;
+            if (value_value_value_0_type == 0) {
+                valueSerializer.writeInt8(0);
+                const auto value_value_value_0_0 = value_value_value_0.value0;
+                valueSerializer.writeString(value_value_value_0_0);
+            }
+            else if (value_value_value_0_type == 1) {
+                valueSerializer.writeInt8(1);
+                const auto value_value_value_0_1 = value_value_value_0.value1;
+                Resource_serializer::write(valueSerializer, value_value_value_0_1);
+            }
         }
-        else if (value_arrowOffset_value_type == 1) {
+        else if (value_value_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
-            valueSerializer.writeNumber(value_arrowOffset_value_1);
-        }
-        else if (value_arrowOffset_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
+            const auto value_value_value_1 = value_value_value.value1;
+            valueSerializer.writeInt32(value_value_value_1.length);
+            for (int value_value_value_1_counter_i = 0; value_value_value_1_counter_i < value_value_value_1.length; value_value_value_1_counter_i++) {
+                const Ark_ResourceStr value_value_value_1_element = value_value_value_1.array[value_value_value_1_counter_i];
+                Ark_Int32 value_value_value_1_element_type = INTEROP_RUNTIME_UNDEFINED;
+                value_value_value_1_element_type = value_value_value_1_element.selector;
+                if (value_value_value_1_element_type == 0) {
+                    valueSerializer.writeInt8(0);
+                    const auto value_value_value_1_element_0 = value_value_value_1_element.value0;
+                    valueSerializer.writeString(value_value_value_1_element_0);
+                }
+                else if (value_value_value_1_element_type == 1) {
+                    valueSerializer.writeInt8(1);
+                    const auto value_value_value_1_element_1 = value_value_value_1_element.value1;
+                    Resource_serializer::write(valueSerializer, value_value_value_1_element_1);
+                }
+            }
         }
     }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
-    }
-    const auto value_mask = value.mask;
-    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
-    value_mask_type = runtimeType(value_mask);
-    valueSerializer.writeInt8(value_mask_type);
-    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_mask_value = value_mask.value;
-        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_mask_value_type = value_mask_value.selector;
-        if (value_mask_value_type == 0) {
+    const auto value_selected = value.selected;
+    Ark_Int32 value_selected_type = INTEROP_RUNTIME_UNDEFINED;
+    value_selected_type = runtimeType(value_selected);
+    valueSerializer.writeInt8(value_selected_type);
+    if ((value_selected_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_selected_value = value_selected.value;
+        Ark_Int32 value_selected_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_selected_value_type = value_selected_value.selector;
+        if (value_selected_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_mask_value_0 = value_mask_value.value0;
-            valueSerializer.writeBoolean(value_mask_value_0);
+            const auto value_selected_value_0 = value_selected_value.value0;
+            valueSerializer.writeNumber(value_selected_value_0);
         }
-        else if (value_mask_value_type == 1) {
+        else if (value_selected_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_mask_value_1 = value_mask_value.value1;
-            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
+            const auto value_selected_value_1 = value_selected_value.value1;
+            valueSerializer.writeInt32(value_selected_value_1.length);
+            for (int value_selected_value_1_counter_i = 0; value_selected_value_1_counter_i < value_selected_value_1.length; value_selected_value_1_counter_i++) {
+                const Ark_Number value_selected_value_1_element = value_selected_value_1.array[value_selected_value_1_counter_i];
+                valueSerializer.writeNumber(value_selected_value_1_element);
+            }
         }
     }
-    const auto value_targetSpace = value.targetSpace;
-    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
-    value_targetSpace_type = runtimeType(value_targetSpace);
-    valueSerializer.writeInt8(value_targetSpace_type);
-    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_targetSpace_value = value_targetSpace.value;
-        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_targetSpace_value_type = value_targetSpace_value.selector;
-        if (value_targetSpace_value_type == 0) {
+    const auto value_columnWidths = value.columnWidths;
+    Ark_Int32 value_columnWidths_type = INTEROP_RUNTIME_UNDEFINED;
+    value_columnWidths_type = runtimeType(value_columnWidths);
+    valueSerializer.writeInt8(value_columnWidths_type);
+    if ((value_columnWidths_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_columnWidths_value = value_columnWidths.value;
+        valueSerializer.writeInt32(value_columnWidths_value.length);
+        for (int value_columnWidths_value_counter_i = 0; value_columnWidths_value_counter_i < value_columnWidths_value.length; value_columnWidths_value_counter_i++) {
+            const Ark_LengthMetrics value_columnWidths_value_element = value_columnWidths_value.array[value_columnWidths_value_counter_i];
+            LengthMetrics_serializer::write(valueSerializer, value_columnWidths_value_element);
+        }
+    }
+    const auto value_defaultPickerItemHeight = value.defaultPickerItemHeight;
+    Ark_Int32 value_defaultPickerItemHeight_type = INTEROP_RUNTIME_UNDEFINED;
+    value_defaultPickerItemHeight_type = runtimeType(value_defaultPickerItemHeight);
+    valueSerializer.writeInt8(value_defaultPickerItemHeight_type);
+    if ((value_defaultPickerItemHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_defaultPickerItemHeight_value = value_defaultPickerItemHeight.value;
+        Ark_Int32 value_defaultPickerItemHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_defaultPickerItemHeight_value_type = value_defaultPickerItemHeight_value.selector;
+        if (value_defaultPickerItemHeight_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
-            valueSerializer.writeString(value_targetSpace_value_0);
+            const auto value_defaultPickerItemHeight_value_0 = value_defaultPickerItemHeight_value.value0;
+            valueSerializer.writeNumber(value_defaultPickerItemHeight_value_0);
         }
-        else if (value_targetSpace_value_type == 1) {
+        else if (value_defaultPickerItemHeight_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
-            valueSerializer.writeNumber(value_targetSpace_value_1);
-        }
-        else if (value_targetSpace_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
-            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
+            const auto value_defaultPickerItemHeight_value_1 = value_defaultPickerItemHeight_value.value1;
+            valueSerializer.writeString(value_defaultPickerItemHeight_value_1);
         }
     }
+    const auto value_canLoop = value.canLoop;
+    Ark_Int32 value_canLoop_type = INTEROP_RUNTIME_UNDEFINED;
+    value_canLoop_type = runtimeType(value_canLoop);
+    valueSerializer.writeInt8(value_canLoop_type);
+    if ((value_canLoop_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_canLoop_value = value_canLoop.value;
+        valueSerializer.writeBoolean(value_canLoop_value);
+    }
+    const auto value_disappearTextStyle = value.disappearTextStyle;
+    Ark_Int32 value_disappearTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_disappearTextStyle_type = runtimeType(value_disappearTextStyle);
+    valueSerializer.writeInt8(value_disappearTextStyle_type);
+    if ((value_disappearTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_disappearTextStyle_value = value_disappearTextStyle.value;
+        PickerTextStyle_serializer::write(valueSerializer, value_disappearTextStyle_value);
+    }
+    const auto value_textStyle = value.textStyle;
+    Ark_Int32 value_textStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_textStyle_type = runtimeType(value_textStyle);
+    valueSerializer.writeInt8(value_textStyle_type);
+    if ((value_textStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_textStyle_value = value_textStyle.value;
+        PickerTextStyle_serializer::write(valueSerializer, value_textStyle_value);
+    }
+    const auto value_acceptButtonStyle = value.acceptButtonStyle;
+    Ark_Int32 value_acceptButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_acceptButtonStyle_type = runtimeType(value_acceptButtonStyle);
+    valueSerializer.writeInt8(value_acceptButtonStyle_type);
+    if ((value_acceptButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_acceptButtonStyle_value = value_acceptButtonStyle.value;
+        PickerDialogButtonStyle_serializer::write(valueSerializer, value_acceptButtonStyle_value);
+    }
+    const auto value_cancelButtonStyle = value.cancelButtonStyle;
+    Ark_Int32 value_cancelButtonStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_cancelButtonStyle_type = runtimeType(value_cancelButtonStyle);
+    valueSerializer.writeInt8(value_cancelButtonStyle_type);
+    if ((value_cancelButtonStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_cancelButtonStyle_value = value_cancelButtonStyle.value;
+        PickerDialogButtonStyle_serializer::write(valueSerializer, value_cancelButtonStyle_value);
+    }
+    const auto value_selectedTextStyle = value.selectedTextStyle;
+    Ark_Int32 value_selectedTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_selectedTextStyle_type = runtimeType(value_selectedTextStyle);
+    valueSerializer.writeInt8(value_selectedTextStyle_type);
+    if ((value_selectedTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_selectedTextStyle_value = value_selectedTextStyle.value;
+        PickerTextStyle_serializer::write(valueSerializer, value_selectedTextStyle_value);
+    }
+    const auto value_disableTextStyleAnimation = value.disableTextStyleAnimation;
+    Ark_Int32 value_disableTextStyleAnimation_type = INTEROP_RUNTIME_UNDEFINED;
+    value_disableTextStyleAnimation_type = runtimeType(value_disableTextStyleAnimation);
+    valueSerializer.writeInt8(value_disableTextStyleAnimation_type);
+    if ((value_disableTextStyleAnimation_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_disableTextStyleAnimation_value = value_disableTextStyleAnimation.value;
+        valueSerializer.writeBoolean(value_disableTextStyleAnimation_value);
+    }
+    const auto value_defaultTextStyle = value.defaultTextStyle;
+    Ark_Int32 value_defaultTextStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_defaultTextStyle_type = runtimeType(value_defaultTextStyle);
+    valueSerializer.writeInt8(value_defaultTextStyle_type);
+    if ((value_defaultTextStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_defaultTextStyle_value = value_defaultTextStyle.value;
+        TextPickerTextStyle_serializer::write(valueSerializer, value_defaultTextStyle_value);
+    }
+    const auto value_onAccept = value.onAccept;
+    Ark_Int32 value_onAccept_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onAccept_type = runtimeType(value_onAccept);
+    valueSerializer.writeInt8(value_onAccept_type);
+    if ((value_onAccept_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onAccept_value = value_onAccept.value;
+        valueSerializer.writeCallbackResource(value_onAccept_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onAccept_value.callSync));
+    }
+    const auto value_onCancel = value.onCancel;
+    Ark_Int32 value_onCancel_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onCancel_type = runtimeType(value_onCancel);
+    valueSerializer.writeInt8(value_onCancel_type);
+    if ((value_onCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onCancel_value = value_onCancel.value;
+        valueSerializer.writeCallbackResource(value_onCancel_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onCancel_value.callSync));
+    }
+    const auto value_onChange = value.onChange;
+    Ark_Int32 value_onChange_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onChange_type = runtimeType(value_onChange);
+    valueSerializer.writeInt8(value_onChange_type);
+    if ((value_onChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onChange_value = value_onChange.value;
+        valueSerializer.writeCallbackResource(value_onChange_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onChange_value.callSync));
+    }
+    const auto value_onScrollStop = value.onScrollStop;
+    Ark_Int32 value_onScrollStop_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onScrollStop_type = runtimeType(value_onScrollStop);
+    valueSerializer.writeInt8(value_onScrollStop_type);
+    if ((value_onScrollStop_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onScrollStop_value = value_onScrollStop.value;
+        valueSerializer.writeCallbackResource(value_onScrollStop_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onScrollStop_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onScrollStop_value.callSync));
+    }
+    const auto value_onEnterSelectedArea = value.onEnterSelectedArea;
+    Ark_Int32 value_onEnterSelectedArea_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onEnterSelectedArea_type = runtimeType(value_onEnterSelectedArea);
+    valueSerializer.writeInt8(value_onEnterSelectedArea_type);
+    if ((value_onEnterSelectedArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onEnterSelectedArea_value = value_onEnterSelectedArea.value;
+        valueSerializer.writeCallbackResource(value_onEnterSelectedArea_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onEnterSelectedArea_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onEnterSelectedArea_value.callSync));
+    }
+    const auto value_maskRect = value.maskRect;
+    Ark_Int32 value_maskRect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_maskRect_type = runtimeType(value_maskRect);
+    valueSerializer.writeInt8(value_maskRect_type);
+    if ((value_maskRect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_maskRect_value = value_maskRect.value;
+        Rectangle_serializer::write(valueSerializer, value_maskRect_value);
+    }
+    const auto value_alignment = value.alignment;
+    Ark_Int32 value_alignment_type = INTEROP_RUNTIME_UNDEFINED;
+    value_alignment_type = runtimeType(value_alignment);
+    valueSerializer.writeInt8(value_alignment_type);
+    if ((value_alignment_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_alignment_value = value_alignment.value;
+        valueSerializer.writeInt32(static_cast<Ark_DialogAlignment>(value_alignment_value));
+    }
     const auto value_offset = value.offset;
     Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
     value_offset_type = runtimeType(value_offset);
     valueSerializer.writeInt8(value_offset_type);
     if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
         const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
+        Offset_serializer::write(valueSerializer, value_offset_value);
     }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if (value_width_value_type == 0) {
+    const auto value_backgroundColor = value.backgroundColor;
+    Ark_Int32 value_backgroundColor_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundColor_type = runtimeType(value_backgroundColor);
+    valueSerializer.writeInt8(value_backgroundColor_type);
+    if ((value_backgroundColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundColor_value = value_backgroundColor.value;
+        Ark_Int32 value_backgroundColor_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_backgroundColor_value_type = value_backgroundColor_value.selector;
+        if (value_backgroundColor_value_type == 0) {
             valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            valueSerializer.writeString(value_width_value_0);
+            const auto value_backgroundColor_value_0 = value_backgroundColor_value.value0;
+            valueSerializer.writeInt32(static_cast<Ark_Color>(value_backgroundColor_value_0));
         }
-        else if (value_width_value_type == 1) {
+        else if (value_backgroundColor_value_type == 1) {
             valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            valueSerializer.writeNumber(value_width_value_1);
+            const auto value_backgroundColor_value_1 = value_backgroundColor_value.value1;
+            valueSerializer.writeNumber(value_backgroundColor_value_1);
         }
-        else if (value_width_value_type == 2) {
+        else if (value_backgroundColor_value_type == 2) {
             valueSerializer.writeInt8(2);
-            const auto value_width_value_2 = value_width_value.value2;
-            Resource_serializer::write(valueSerializer, value_width_value_2);
+            const auto value_backgroundColor_value_2 = value_backgroundColor_value.value2;
+            valueSerializer.writeString(value_backgroundColor_value_2);
+        }
+        else if (value_backgroundColor_value_type == 3) {
+            valueSerializer.writeInt8(3);
+            const auto value_backgroundColor_value_3 = value_backgroundColor_value.value3;
+            Resource_serializer::write(valueSerializer, value_backgroundColor_value_3);
         }
     }
-    const auto value_arrowPointPosition = value.arrowPointPosition;
-    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
-    valueSerializer.writeInt8(value_arrowPointPosition_type);
-    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
-        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
+    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
+    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
+    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
+    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
+        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
     }
-    const auto value_arrowWidth = value.arrowWidth;
-    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowWidth_type = runtimeType(value_arrowWidth);
-    valueSerializer.writeInt8(value_arrowWidth_type);
-    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowWidth_value = value_arrowWidth.value;
-        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowWidth_value_type = value_arrowWidth_value.selector;
-        if (value_arrowWidth_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
-            valueSerializer.writeString(value_arrowWidth_value_0);
-        }
-        else if (value_arrowWidth_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
-            valueSerializer.writeNumber(value_arrowWidth_value_1);
-        }
-        else if (value_arrowWidth_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
-        }
+    const auto value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions;
+    Ark_Int32 value_backgroundBlurStyleOptions_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions);
+    valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type);
+    if ((value_backgroundBlurStyleOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions.value;
+        BackgroundBlurStyleOptions_serializer::write(valueSerializer, value_backgroundBlurStyleOptions_value);
     }
-    const auto value_arrowHeight = value.arrowHeight;
-    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowHeight_type = runtimeType(value_arrowHeight);
-    valueSerializer.writeInt8(value_arrowHeight_type);
-    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowHeight_value = value_arrowHeight.value;
-        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowHeight_value_type = value_arrowHeight_value.selector;
-        if (value_arrowHeight_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
-            valueSerializer.writeString(value_arrowHeight_value_0);
-        }
-        else if (value_arrowHeight_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
-            valueSerializer.writeNumber(value_arrowHeight_value_1);
-        }
-        else if (value_arrowHeight_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
-        }
+    const auto value_backgroundEffect = value.backgroundEffect;
+    Ark_Int32 value_backgroundEffect_type = INTEROP_RUNTIME_UNDEFINED;
+    value_backgroundEffect_type = runtimeType(value_backgroundEffect);
+    valueSerializer.writeInt8(value_backgroundEffect_type);
+    if ((value_backgroundEffect_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_backgroundEffect_value = value_backgroundEffect.value;
+        BackgroundEffectOptions_serializer::write(valueSerializer, value_backgroundEffect_value);
     }
-    const auto value_radius = value.radius;
-    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_radius_type = runtimeType(value_radius);
-    valueSerializer.writeInt8(value_radius_type);
-    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_radius_value = value_radius.value;
-        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_radius_value_type = value_radius_value.selector;
-        if (value_radius_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_radius_value_0 = value_radius_value.value0;
-            valueSerializer.writeString(value_radius_value_0);
-        }
-        else if (value_radius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_radius_value_1 = value_radius_value.value1;
-            valueSerializer.writeNumber(value_radius_value_1);
-        }
-        else if (value_radius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_radius_value_2 = value_radius_value.value2;
-            Resource_serializer::write(valueSerializer, value_radius_value_2);
-        }
+    const auto value_onDidAppear = value.onDidAppear;
+    Ark_Int32 value_onDidAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidAppear_type = runtimeType(value_onDidAppear);
+    valueSerializer.writeInt8(value_onDidAppear_type);
+    if ((value_onDidAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidAppear_value = value_onDidAppear.value;
+        valueSerializer.writeCallbackResource(value_onDidAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidAppear_value.callSync));
+    }
+    const auto value_onDidDisappear = value.onDidDisappear;
+    Ark_Int32 value_onDidDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onDidDisappear_type = runtimeType(value_onDidDisappear);
+    valueSerializer.writeInt8(value_onDidDisappear_type);
+    if ((value_onDidDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onDidDisappear_value = value_onDidDisappear.value;
+        valueSerializer.writeCallbackResource(value_onDidDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onDidDisappear_value.callSync));
+    }
+    const auto value_onWillAppear = value.onWillAppear;
+    Ark_Int32 value_onWillAppear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillAppear_type = runtimeType(value_onWillAppear);
+    valueSerializer.writeInt8(value_onWillAppear_type);
+    if ((value_onWillAppear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillAppear_value = value_onWillAppear.value;
+        valueSerializer.writeCallbackResource(value_onWillAppear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillAppear_value.callSync));
+    }
+    const auto value_onWillDisappear = value.onWillDisappear;
+    Ark_Int32 value_onWillDisappear_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onWillDisappear_type = runtimeType(value_onWillDisappear);
+    valueSerializer.writeInt8(value_onWillDisappear_type);
+    if ((value_onWillDisappear_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onWillDisappear_value = value_onWillDisappear.value;
+        valueSerializer.writeCallbackResource(value_onWillDisappear_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDisappear_value.callSync));
     }
     const auto value_shadow = value.shadow;
     Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
@@ -117384,51 +119895,6 @@ inline void PopupCommonOptions_serializer::write(SerializerBase& buffer, Ark_Pop
             valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
         }
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
-    }
-    const auto value_focusable = value.focusable;
-    Ark_Int32 value_focusable_type = INTEROP_RUNTIME_UNDEFINED;
-    value_focusable_type = runtimeType(value_focusable);
-    valueSerializer.writeInt8(value_focusable_type);
-    if ((value_focusable_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_focusable_value = value_focusable.value;
-        valueSerializer.writeBoolean(value_focusable_value);
-    }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
-    }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
-        if (value_onWillDismiss_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
-            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
-        }
-        else if (value_onWillDismiss_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
-            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
-        }
-    }
     const auto value_enableHoverMode = value.enableHoverMode;
     Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
     value_enableHoverMode_type = runtimeType(value_enableHoverMode);
@@ -117437,1118 +119903,975 @@ inline void PopupCommonOptions_serializer::write(SerializerBase& buffer, Ark_Pop
         const auto value_enableHoverMode_value = value_enableHoverMode.value;
         valueSerializer.writeBoolean(value_enableHoverMode_value);
     }
-    const auto value_followTransformOfTarget = value.followTransformOfTarget;
-    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
-    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
-    valueSerializer.writeInt8(value_followTransformOfTarget_type);
-    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
-        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
+    const auto value_hoverModeArea = value.hoverModeArea;
+    Ark_Int32 value_hoverModeArea_type = INTEROP_RUNTIME_UNDEFINED;
+    value_hoverModeArea_type = runtimeType(value_hoverModeArea);
+    valueSerializer.writeInt8(value_hoverModeArea_type);
+    if ((value_hoverModeArea_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_hoverModeArea_value = value_hoverModeArea.value;
+        valueSerializer.writeInt32(static_cast<Ark_HoverModeAreaType>(value_hoverModeArea_value));
+    }
+    const auto value_enableHapticFeedback = value.enableHapticFeedback;
+    Ark_Int32 value_enableHapticFeedback_type = INTEROP_RUNTIME_UNDEFINED;
+    value_enableHapticFeedback_type = runtimeType(value_enableHapticFeedback);
+    valueSerializer.writeInt8(value_enableHapticFeedback_type);
+    if ((value_enableHapticFeedback_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_enableHapticFeedback_value = value_enableHapticFeedback.value;
+        valueSerializer.writeBoolean(value_enableHapticFeedback_value);
     }
 }
-inline Ark_PopupCommonOptions PopupCommonOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_TextPickerDialogOptions TextPickerDialogOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PopupCommonOptions value = {};
+    Ark_TextPickerDialogOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Placement placement_buf = {};
-    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
-    }
-    value.placement = placement_buf;
-    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ResourceColor popupColor_buf = {};
-    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
-        Ark_ResourceColor popupColor_buf_ = {};
-        popupColor_buf_.selector = popupColor_buf__selector;
-        if (popupColor_buf__selector == 0) {
-            popupColor_buf_.selector = 0;
-            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (popupColor_buf__selector == 1) {
-            popupColor_buf_.selector = 1;
-            popupColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (popupColor_buf__selector == 2) {
-            popupColor_buf_.selector = 2;
-            popupColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (popupColor_buf__selector == 3) {
-            popupColor_buf_.selector = 3;
-            popupColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
+    const Ark_Int8 range_buf_selector = valueDeserializer.readInt8();
+    Ark_Union_Array_String_Array_Array_String_Resource_Array_TextPickerRangeContent_Array_TextCascadePickerRangeContent range_buf = {};
+    range_buf.selector = range_buf_selector;
+    if (range_buf_selector == 0) {
+        range_buf.selector = 0;
+        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
+        Array_String range_buf_u = {};
+        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
+        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
+        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
+            range_buf_u.array[range_buf_u_i] = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        popupColor_buf.value = static_cast<Ark_ResourceColor>(popupColor_buf_);
-    }
-    value.popupColor = popupColor_buf;
-    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableArrow_buf = {};
-    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableArrow_buf.value = valueDeserializer.readBoolean();
-    }
-    value.enableArrow = enableArrow_buf;
-    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean autoCancel_buf = {};
-    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        autoCancel_buf.value = valueDeserializer.readBoolean();
-    }
-    value.autoCancel = autoCancel_buf;
-    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupStateChangeCallback onStateChange_buf = {};
-    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
+        range_buf.value0 = range_buf_u;
     }
-    value.onStateChange = onStateChange_buf;
-    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length arrowOffset_buf = {};
-    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
-        Ark_Length arrowOffset_buf_ = {};
-        arrowOffset_buf_.selector = arrowOffset_buf__selector;
-        if (arrowOffset_buf__selector == 0) {
-            arrowOffset_buf_.selector = 0;
-            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowOffset_buf__selector == 1) {
-            arrowOffset_buf_.selector = 1;
-            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowOffset_buf__selector == 2) {
-            arrowOffset_buf_.selector = 2;
-            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
+    else if (range_buf_selector == 1) {
+        range_buf.selector = 1;
+        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
+        Array_Array_String range_buf_u = {};
+        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
+        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
+        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
+            const Ark_Int32 range_buf_u_buf_length = valueDeserializer.readInt32();
+            Array_String range_buf_u_buf = {};
+            valueDeserializer.resizeArray<std::decay<decltype(range_buf_u_buf)>::type,
+        std::decay<decltype(*range_buf_u_buf.array)>::type>(&range_buf_u_buf, range_buf_u_buf_length);
+            for (int range_buf_u_buf_i = 0; range_buf_u_buf_i < range_buf_u_buf_length; range_buf_u_buf_i++) {
+                range_buf_u_buf.array[range_buf_u_buf_i] = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            range_buf_u.array[range_buf_u_i] = range_buf_u_buf;
         }
-        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
-    }
-    value.arrowOffset = arrowOffset_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+        range_buf.value1 = range_buf_u;
     }
-    value.showInSubWindow = showInSubWindow_buf;
-    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_PopupMaskType mask_buf = {};
-    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
-        mask_buf_.selector = mask_buf__selector;
-        if (mask_buf__selector == 0) {
-            mask_buf_.selector = 0;
-            mask_buf_.value0 = valueDeserializer.readBoolean();
-        }
-        else if (mask_buf__selector == 1) {
-            mask_buf_.selector = 1;
-            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
-        }
-        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
+    else if (range_buf_selector == 2) {
+        range_buf.selector = 2;
+        range_buf.value2 = Resource_serializer::read(valueDeserializer);
     }
-    value.mask = mask_buf;
-    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length targetSpace_buf = {};
-    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
-        Ark_Length targetSpace_buf_ = {};
-        targetSpace_buf_.selector = targetSpace_buf__selector;
-        if (targetSpace_buf__selector == 0) {
-            targetSpace_buf_.selector = 0;
-            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (targetSpace_buf__selector == 1) {
-            targetSpace_buf_.selector = 1;
-            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (targetSpace_buf__selector == 2) {
-            targetSpace_buf_.selector = 2;
-            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
+    else if (range_buf_selector == 3) {
+        range_buf.selector = 3;
+        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
+        Array_TextPickerRangeContent range_buf_u = {};
+        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
+        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
+        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
+            range_buf_u.array[range_buf_u_i] = TextPickerRangeContent_serializer::read(valueDeserializer);
         }
-        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
-    }
-    value.targetSpace = targetSpace_buf;
-    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
-    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
+        range_buf.value3 = range_buf_u;
     }
-    value.offset = offset_buf;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension width_buf_ = {};
-        width_buf_.selector = width_buf__selector;
-        if (width_buf__selector == 0) {
-            width_buf_.selector = 0;
-            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (width_buf__selector == 2) {
-            width_buf_.selector = 2;
-            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
+    else if (range_buf_selector == 4) {
+        range_buf.selector = 4;
+        const Ark_Int32 range_buf_u_length = valueDeserializer.readInt32();
+        Array_TextCascadePickerRangeContent range_buf_u = {};
+        valueDeserializer.resizeArray<std::decay<decltype(range_buf_u)>::type,
+        std::decay<decltype(*range_buf_u.array)>::type>(&range_buf_u, range_buf_u_length);
+        for (int range_buf_u_i = 0; range_buf_u_i < range_buf_u_length; range_buf_u_i++) {
+            range_buf_u.array[range_buf_u_i] = TextCascadePickerRangeContent_serializer::read(valueDeserializer);
         }
-        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
+        range_buf.value4 = range_buf_u;
     }
-    value.width = width_buf;
-    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ArrowPointPosition arrowPointPosition_buf = {};
-    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
+    else {
+        INTEROP_FATAL("One of the branches for range_buf has to be chosen through deserialisation.");
     }
-    value.arrowPointPosition = arrowPointPosition_buf;
-    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowWidth_buf = {};
-    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.range = static_cast<Ark_Union_Array_String_Array_Array_String_Resource_Array_TextPickerRangeContent_Array_TextCascadePickerRangeContent>(range_buf);
+    const auto value_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ResourceStr_Array_ResourceStr value_buf = {};
+    value_buf.tag = value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowWidth_buf_ = {};
-        arrowWidth_buf_.selector = arrowWidth_buf__selector;
-        if (arrowWidth_buf__selector == 0) {
-            arrowWidth_buf_.selector = 0;
-            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowWidth_buf__selector == 1) {
-            arrowWidth_buf_.selector = 1;
-            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 value_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ResourceStr_Array_ResourceStr value_buf_ = {};
+        value_buf_.selector = value_buf__selector;
+        if (value_buf__selector == 0) {
+            value_buf_.selector = 0;
+            const Ark_Int8 value_buf__u_selector = valueDeserializer.readInt8();
+            Ark_ResourceStr value_buf__u = {};
+            value_buf__u.selector = value_buf__u_selector;
+            if (value_buf__u_selector == 0) {
+                value_buf__u.selector = 0;
+                value_buf__u.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+            }
+            else if (value_buf__u_selector == 1) {
+                value_buf__u.selector = 1;
+                value_buf__u.value1 = Resource_serializer::read(valueDeserializer);
+            }
+            else {
+                INTEROP_FATAL("One of the branches for value_buf__u has to be chosen through deserialisation.");
+            }
+            value_buf_.value0 = static_cast<Ark_ResourceStr>(value_buf__u);
         }
-        else if (arrowWidth_buf__selector == 2) {
-            arrowWidth_buf_.selector = 2;
-            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (value_buf__selector == 1) {
+            value_buf_.selector = 1;
+            const Ark_Int32 value_buf__u_length = valueDeserializer.readInt32();
+            Array_ResourceStr value_buf__u = {};
+            valueDeserializer.resizeArray<std::decay<decltype(value_buf__u)>::type,
+        std::decay<decltype(*value_buf__u.array)>::type>(&value_buf__u, value_buf__u_length);
+            for (int value_buf__u_i = 0; value_buf__u_i < value_buf__u_length; value_buf__u_i++) {
+                const Ark_Int8 value_buf__u_buf_selector = valueDeserializer.readInt8();
+                Ark_ResourceStr value_buf__u_buf = {};
+                value_buf__u_buf.selector = value_buf__u_buf_selector;
+                if (value_buf__u_buf_selector == 0) {
+                    value_buf__u_buf.selector = 0;
+                    value_buf__u_buf.value0 = static_cast<Ark_String>(valueDeserializer.readString());
+                }
+                else if (value_buf__u_buf_selector == 1) {
+                    value_buf__u_buf.selector = 1;
+                    value_buf__u_buf.value1 = Resource_serializer::read(valueDeserializer);
+                }
+                else {
+                    INTEROP_FATAL("One of the branches for value_buf__u_buf has to be chosen through deserialisation.");
+                }
+                value_buf__u.array[value_buf__u_i] = static_cast<Ark_ResourceStr>(value_buf__u_buf);
+            }
+            value_buf_.value1 = value_buf__u;
         }
         else {
-            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for value_buf_ has to be chosen through deserialisation.");
         }
-        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
+        value_buf.value = static_cast<Ark_Union_ResourceStr_Array_ResourceStr>(value_buf_);
     }
-    value.arrowWidth = arrowWidth_buf;
-    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowHeight_buf = {};
-    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.value = value_buf;
+    const auto selected_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_Array_Number selected_buf = {};
+    selected_buf.tag = selected_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((selected_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowHeight_buf_ = {};
-        arrowHeight_buf_.selector = arrowHeight_buf__selector;
-        if (arrowHeight_buf__selector == 0) {
-            arrowHeight_buf_.selector = 0;
-            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowHeight_buf__selector == 1) {
-            arrowHeight_buf_.selector = 1;
-            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+        const Ark_Int8 selected_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_Array_Number selected_buf_ = {};
+        selected_buf_.selector = selected_buf__selector;
+        if (selected_buf__selector == 0) {
+            selected_buf_.selector = 0;
+            selected_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (arrowHeight_buf__selector == 2) {
-            arrowHeight_buf_.selector = 2;
-            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
+        else if (selected_buf__selector == 1) {
+            selected_buf_.selector = 1;
+            const Ark_Int32 selected_buf__u_length = valueDeserializer.readInt32();
+            Array_Number selected_buf__u = {};
+            valueDeserializer.resizeArray<std::decay<decltype(selected_buf__u)>::type,
+        std::decay<decltype(*selected_buf__u.array)>::type>(&selected_buf__u, selected_buf__u_length);
+            for (int selected_buf__u_i = 0; selected_buf__u_i < selected_buf__u_length; selected_buf__u_i++) {
+                selected_buf__u.array[selected_buf__u_i] = static_cast<Ark_Number>(valueDeserializer.readNumber());
+            }
+            selected_buf_.value1 = selected_buf__u;
         }
         else {
-            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for selected_buf_ has to be chosen through deserialisation.");
         }
-        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
+        selected_buf.value = static_cast<Ark_Union_Number_Array_Number>(selected_buf_);
     }
-    value.arrowHeight = arrowHeight_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.selected = selected_buf;
+    const auto columnWidths_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Array_LengthMetrics columnWidths_buf = {};
+    columnWidths_buf.tag = columnWidths_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((columnWidths_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (radius_buf__selector == 2) {
-            radius_buf_.selector = 2;
-            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
+        const Ark_Int32 columnWidths_buf__length = valueDeserializer.readInt32();
+        Array_LengthMetrics columnWidths_buf_ = {};
+        valueDeserializer.resizeArray<std::decay<decltype(columnWidths_buf_)>::type,
+        std::decay<decltype(*columnWidths_buf_.array)>::type>(&columnWidths_buf_, columnWidths_buf__length);
+        for (int columnWidths_buf__i = 0; columnWidths_buf__i < columnWidths_buf__length; columnWidths_buf__i++) {
+            columnWidths_buf_.array[columnWidths_buf__i] = static_cast<Ark_LengthMetrics>(LengthMetrics_serializer::read(valueDeserializer));
         }
-        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
+        columnWidths_buf.value = columnWidths_buf_;
     }
-    value.radius = radius_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.columnWidths = columnWidths_buf;
+    const auto defaultPickerItemHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_Number_String defaultPickerItemHeight_buf = {};
+    defaultPickerItemHeight_buf.tag = defaultPickerItemHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((defaultPickerItemHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
+        const Ark_Int8 defaultPickerItemHeight_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_Number_String defaultPickerItemHeight_buf_ = {};
+        defaultPickerItemHeight_buf_.selector = defaultPickerItemHeight_buf__selector;
+        if (defaultPickerItemHeight_buf__selector == 0) {
+            defaultPickerItemHeight_buf_.selector = 0;
+            defaultPickerItemHeight_buf_.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
+        else if (defaultPickerItemHeight_buf__selector == 1) {
+            defaultPickerItemHeight_buf_.selector = 1;
+            defaultPickerItemHeight_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
         }
         else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for defaultPickerItemHeight_buf_ has to be chosen through deserialisation.");
         }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+        defaultPickerItemHeight_buf.value = static_cast<Ark_Union_Number_String>(defaultPickerItemHeight_buf_);
     }
-    value.shadow = shadow_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.defaultPickerItemHeight = defaultPickerItemHeight_buf;
+    const auto canLoop_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean canLoop_buf = {};
+    canLoop_buf.tag = canLoop_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((canLoop_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+        canLoop_buf.value = valueDeserializer.readBoolean();
     }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto focusable_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean focusable_buf = {};
-    focusable_buf.tag = focusable_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((focusable_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.canLoop = canLoop_buf;
+    const auto disappearTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerTextStyle disappearTextStyle_buf = {};
+    disappearTextStyle_buf.tag = disappearTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((disappearTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        focusable_buf.value = valueDeserializer.readBoolean();
+        disappearTextStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
     }
-    value.focusable = focusable_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.disappearTextStyle = disappearTextStyle_buf;
+    const auto textStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerTextStyle textStyle_buf = {};
+    textStyle_buf.tag = textStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((textStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+        textStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
     }
-    value.transition = transition_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.textStyle = textStyle_buf;
+    const auto acceptButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerDialogButtonStyle acceptButtonStyle_buf = {};
+    acceptButtonStyle_buf.tag = acceptButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((acceptButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
-        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
-        if (onWillDismiss_buf__selector == 0) {
-            onWillDismiss_buf_.selector = 0;
-            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
-        }
-        else if (onWillDismiss_buf__selector == 1) {
-            onWillDismiss_buf_.selector = 1;
-            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
-        }
-        else {
-            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
-        }
-        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
+        acceptButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
     }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.acceptButtonStyle = acceptButtonStyle_buf;
+    const auto cancelButtonStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerDialogButtonStyle cancelButtonStyle_buf = {};
+    cancelButtonStyle_buf.tag = cancelButtonStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((cancelButtonStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+        cancelButtonStyle_buf.value = PickerDialogButtonStyle_serializer::read(valueDeserializer);
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean followTransformOfTarget_buf = {};
-    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.cancelButtonStyle = cancelButtonStyle_buf;
+    const auto selectedTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_PickerTextStyle selectedTextStyle_buf = {};
+    selectedTextStyle_buf.tag = selectedTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((selectedTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
-    }
-    value.followTransformOfTarget = followTransformOfTarget_buf;
-    return value;
-}
-inline void PopupOptions_serializer::write(SerializerBase& buffer, Ark_PopupOptions value)
-{
-    SerializerBase& valueSerializer = buffer;
-    const auto value_message = value.message;
-    valueSerializer.writeString(value_message);
-    const auto value_placement = value.placement;
-    Ark_Int32 value_placement_type = INTEROP_RUNTIME_UNDEFINED;
-    value_placement_type = runtimeType(value_placement);
-    valueSerializer.writeInt8(value_placement_type);
-    if ((value_placement_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_placement_value = value_placement.value;
-        valueSerializer.writeInt32(static_cast<Ark_Placement>(value_placement_value));
-    }
-    const auto value_primaryButton = value.primaryButton;
-    Ark_Int32 value_primaryButton_type = INTEROP_RUNTIME_UNDEFINED;
-    value_primaryButton_type = runtimeType(value_primaryButton);
-    valueSerializer.writeInt8(value_primaryButton_type);
-    if ((value_primaryButton_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_primaryButton_value = value_primaryButton.value;
-        PopupButton_serializer::write(valueSerializer, value_primaryButton_value);
-    }
-    const auto value_secondaryButton = value.secondaryButton;
-    Ark_Int32 value_secondaryButton_type = INTEROP_RUNTIME_UNDEFINED;
-    value_secondaryButton_type = runtimeType(value_secondaryButton);
-    valueSerializer.writeInt8(value_secondaryButton_type);
-    if ((value_secondaryButton_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_secondaryButton_value = value_secondaryButton.value;
-        PopupButton_serializer::write(valueSerializer, value_secondaryButton_value);
-    }
-    const auto value_onStateChange = value.onStateChange;
-    Ark_Int32 value_onStateChange_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onStateChange_type = runtimeType(value_onStateChange);
-    valueSerializer.writeInt8(value_onStateChange_type);
-    if ((value_onStateChange_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onStateChange_value = value_onStateChange.value;
-        valueSerializer.writeCallbackResource(value_onStateChange_value.resource);
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.call));
-        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onStateChange_value.callSync));
-    }
-    const auto value_arrowOffset = value.arrowOffset;
-    Ark_Int32 value_arrowOffset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowOffset_type = runtimeType(value_arrowOffset);
-    valueSerializer.writeInt8(value_arrowOffset_type);
-    if ((value_arrowOffset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowOffset_value = value_arrowOffset.value;
-        Ark_Int32 value_arrowOffset_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowOffset_value_type = value_arrowOffset_value.selector;
-        if (value_arrowOffset_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowOffset_value_0 = value_arrowOffset_value.value0;
-            valueSerializer.writeString(value_arrowOffset_value_0);
-        }
-        else if (value_arrowOffset_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowOffset_value_1 = value_arrowOffset_value.value1;
-            valueSerializer.writeNumber(value_arrowOffset_value_1);
-        }
-        else if (value_arrowOffset_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowOffset_value_2 = value_arrowOffset_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowOffset_value_2);
-        }
+        selectedTextStyle_buf.value = PickerTextStyle_serializer::read(valueDeserializer);
     }
-    const auto value_showInSubWindow = value.showInSubWindow;
-    Ark_Int32 value_showInSubWindow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_showInSubWindow_type = runtimeType(value_showInSubWindow);
-    valueSerializer.writeInt8(value_showInSubWindow_type);
-    if ((value_showInSubWindow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_showInSubWindow_value = value_showInSubWindow.value;
-        valueSerializer.writeBoolean(value_showInSubWindow_value);
+    value.selectedTextStyle = selectedTextStyle_buf;
+    const auto disableTextStyleAnimation_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean disableTextStyleAnimation_buf = {};
+    disableTextStyleAnimation_buf.tag = disableTextStyleAnimation_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((disableTextStyleAnimation_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        disableTextStyleAnimation_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_mask = value.mask;
-    Ark_Int32 value_mask_type = INTEROP_RUNTIME_UNDEFINED;
-    value_mask_type = runtimeType(value_mask);
-    valueSerializer.writeInt8(value_mask_type);
-    if ((value_mask_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_mask_value = value_mask.value;
-        Ark_Int32 value_mask_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_mask_value_type = value_mask_value.selector;
-        if (value_mask_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_mask_value_0 = value_mask_value.value0;
-            valueSerializer.writeBoolean(value_mask_value_0);
-        }
-        else if (value_mask_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_mask_value_1 = value_mask_value.value1;
-            PopupMaskType_serializer::write(valueSerializer, value_mask_value_1);
-        }
+    value.disableTextStyleAnimation = disableTextStyleAnimation_buf;
+    const auto defaultTextStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_TextPickerTextStyle defaultTextStyle_buf = {};
+    defaultTextStyle_buf.tag = defaultTextStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((defaultTextStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        defaultTextStyle_buf.value = TextPickerTextStyle_serializer::read(valueDeserializer);
     }
-    const auto value_messageOptions = value.messageOptions;
-    Ark_Int32 value_messageOptions_type = INTEROP_RUNTIME_UNDEFINED;
-    value_messageOptions_type = runtimeType(value_messageOptions);
-    valueSerializer.writeInt8(value_messageOptions_type);
-    if ((value_messageOptions_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_messageOptions_value = value_messageOptions.value;
-        PopupMessageOptions_serializer::write(valueSerializer, value_messageOptions_value);
+    value.defaultTextStyle = defaultTextStyle_buf;
+    const auto onAccept_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_TextPickerResult_Void onAccept_buf = {};
+    onAccept_buf.tag = onAccept_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onAccept_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onAccept_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
     }
-    const auto value_targetSpace = value.targetSpace;
-    Ark_Int32 value_targetSpace_type = INTEROP_RUNTIME_UNDEFINED;
-    value_targetSpace_type = runtimeType(value_targetSpace);
-    valueSerializer.writeInt8(value_targetSpace_type);
-    if ((value_targetSpace_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_targetSpace_value = value_targetSpace.value;
-        Ark_Int32 value_targetSpace_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_targetSpace_value_type = value_targetSpace_value.selector;
-        if (value_targetSpace_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_targetSpace_value_0 = value_targetSpace_value.value0;
-            valueSerializer.writeString(value_targetSpace_value_0);
-        }
-        else if (value_targetSpace_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_targetSpace_value_1 = value_targetSpace_value.value1;
-            valueSerializer.writeNumber(value_targetSpace_value_1);
-        }
-        else if (value_targetSpace_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_targetSpace_value_2 = value_targetSpace_value.value2;
-            Resource_serializer::write(valueSerializer, value_targetSpace_value_2);
-        }
+    value.onAccept = onAccept_buf;
+    const auto onCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onCancel_buf = {};
+    onCancel_buf.tag = onCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onCancel_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
     }
-    const auto value_enableArrow = value.enableArrow;
-    Ark_Int32 value_enableArrow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableArrow_type = runtimeType(value_enableArrow);
-    valueSerializer.writeInt8(value_enableArrow_type);
-    if ((value_enableArrow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableArrow_value = value_enableArrow.value;
-        valueSerializer.writeBoolean(value_enableArrow_value);
+    value.onCancel = onCancel_buf;
+    const auto onChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_TextPickerResult_Void onChange_buf = {};
+    onChange_buf.tag = onChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
     }
-    const auto value_offset = value.offset;
-    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
-    value_offset_type = runtimeType(value_offset);
-    valueSerializer.writeInt8(value_offset_type);
-    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_offset_value = value_offset.value;
-        Position_serializer::write(valueSerializer, value_offset_value);
+    value.onChange = onChange_buf;
+    const auto onScrollStop_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_TextPickerResult_Void onScrollStop_buf = {};
+    onScrollStop_buf.tag = onScrollStop_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onScrollStop_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onScrollStop_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
     }
-    const auto value_popupColor = value.popupColor;
-    Ark_Int32 value_popupColor_type = INTEROP_RUNTIME_UNDEFINED;
-    value_popupColor_type = runtimeType(value_popupColor);
-    valueSerializer.writeInt8(value_popupColor_type);
-    if ((value_popupColor_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_popupColor_value = value_popupColor.value;
-        Ark_Int32 value_popupColor_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_popupColor_value_type = value_popupColor_value.selector;
-        if (value_popupColor_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_popupColor_value_0 = value_popupColor_value.value0;
-            valueSerializer.writeInt32(static_cast<Ark_Color>(value_popupColor_value_0));
-        }
-        else if (value_popupColor_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_popupColor_value_1 = value_popupColor_value.value1;
-            valueSerializer.writeString(value_popupColor_value_1);
-        }
-        else if (value_popupColor_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_popupColor_value_2 = value_popupColor_value.value2;
-            Resource_serializer::write(valueSerializer, value_popupColor_value_2);
-        }
-        else if (value_popupColor_value_type == 3) {
-            valueSerializer.writeInt8(3);
-            const auto value_popupColor_value_3 = value_popupColor_value.value3;
-            valueSerializer.writeNumber(value_popupColor_value_3);
-        }
+    value.onScrollStop = onScrollStop_buf;
+    const auto onEnterSelectedArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_TextPickerResult_Void onEnterSelectedArea_buf = {};
+    onEnterSelectedArea_buf.tag = onEnterSelectedArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onEnterSelectedArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onEnterSelectedArea_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_TextPickerResult_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_TextPickerResult value)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_TextPickerResult_Void))))};
     }
-    const auto value_autoCancel = value.autoCancel;
-    Ark_Int32 value_autoCancel_type = INTEROP_RUNTIME_UNDEFINED;
-    value_autoCancel_type = runtimeType(value_autoCancel);
-    valueSerializer.writeInt8(value_autoCancel_type);
-    if ((value_autoCancel_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_autoCancel_value = value_autoCancel.value;
-        valueSerializer.writeBoolean(value_autoCancel_value);
+    value.onEnterSelectedArea = onEnterSelectedArea_buf;
+    const auto maskRect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Rectangle maskRect_buf = {};
+    maskRect_buf.tag = maskRect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((maskRect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        maskRect_buf.value = Rectangle_serializer::read(valueDeserializer);
     }
-    const auto value_width = value.width;
-    Ark_Int32 value_width_type = INTEROP_RUNTIME_UNDEFINED;
-    value_width_type = runtimeType(value_width);
-    valueSerializer.writeInt8(value_width_type);
-    if ((value_width_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_width_value = value_width.value;
-        Ark_Int32 value_width_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_width_value_type = value_width_value.selector;
-        if (value_width_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_width_value_0 = value_width_value.value0;
-            valueSerializer.writeString(value_width_value_0);
-        }
-        else if (value_width_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_width_value_1 = value_width_value.value1;
-            valueSerializer.writeNumber(value_width_value_1);
-        }
-        else if (value_width_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_width_value_2 = value_width_value.value2;
-            Resource_serializer::write(valueSerializer, value_width_value_2);
-        }
+    value.maskRect = maskRect_buf;
+    const auto alignment_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_DialogAlignment alignment_buf = {};
+    alignment_buf.tag = alignment_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((alignment_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        alignment_buf.value = static_cast<Ark_DialogAlignment>(valueDeserializer.readInt32());
     }
-    const auto value_arrowPointPosition = value.arrowPointPosition;
-    Ark_Int32 value_arrowPointPosition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowPointPosition_type = runtimeType(value_arrowPointPosition);
-    valueSerializer.writeInt8(value_arrowPointPosition_type);
-    if ((value_arrowPointPosition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowPointPosition_value = value_arrowPointPosition.value;
-        valueSerializer.writeInt32(static_cast<Ark_ArrowPointPosition>(value_arrowPointPosition_value));
+    value.alignment = alignment_buf;
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Offset offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        offset_buf.value = Offset_serializer::read(valueDeserializer);
     }
-    const auto value_arrowWidth = value.arrowWidth;
-    Ark_Int32 value_arrowWidth_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowWidth_type = runtimeType(value_arrowWidth);
-    valueSerializer.writeInt8(value_arrowWidth_type);
-    if ((value_arrowWidth_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowWidth_value = value_arrowWidth.value;
-        Ark_Int32 value_arrowWidth_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowWidth_value_type = value_arrowWidth_value.selector;
-        if (value_arrowWidth_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowWidth_value_0 = value_arrowWidth_value.value0;
-            valueSerializer.writeString(value_arrowWidth_value_0);
-        }
-        else if (value_arrowWidth_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowWidth_value_1 = value_arrowWidth_value.value1;
-            valueSerializer.writeNumber(value_arrowWidth_value_1);
+    value.offset = offset_buf;
+    const auto backgroundColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceColor backgroundColor_buf = {};
+    backgroundColor_buf.tag = backgroundColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 backgroundColor_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceColor backgroundColor_buf_ = {};
+        backgroundColor_buf_.selector = backgroundColor_buf__selector;
+        if (backgroundColor_buf__selector == 0) {
+            backgroundColor_buf_.selector = 0;
+            backgroundColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
         }
-        else if (value_arrowWidth_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowWidth_value_2 = value_arrowWidth_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowWidth_value_2);
+        else if (backgroundColor_buf__selector == 1) {
+            backgroundColor_buf_.selector = 1;
+            backgroundColor_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
         }
-    }
-    const auto value_arrowHeight = value.arrowHeight;
-    Ark_Int32 value_arrowHeight_type = INTEROP_RUNTIME_UNDEFINED;
-    value_arrowHeight_type = runtimeType(value_arrowHeight);
-    valueSerializer.writeInt8(value_arrowHeight_type);
-    if ((value_arrowHeight_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_arrowHeight_value = value_arrowHeight.value;
-        Ark_Int32 value_arrowHeight_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_arrowHeight_value_type = value_arrowHeight_value.selector;
-        if (value_arrowHeight_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_arrowHeight_value_0 = value_arrowHeight_value.value0;
-            valueSerializer.writeString(value_arrowHeight_value_0);
+        else if (backgroundColor_buf__selector == 2) {
+            backgroundColor_buf_.selector = 2;
+            backgroundColor_buf_.value2 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (value_arrowHeight_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_arrowHeight_value_1 = value_arrowHeight_value.value1;
-            valueSerializer.writeNumber(value_arrowHeight_value_1);
+        else if (backgroundColor_buf__selector == 3) {
+            backgroundColor_buf_.selector = 3;
+            backgroundColor_buf_.value3 = Resource_serializer::read(valueDeserializer);
         }
-        else if (value_arrowHeight_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_arrowHeight_value_2 = value_arrowHeight_value.value2;
-            Resource_serializer::write(valueSerializer, value_arrowHeight_value_2);
+        else {
+            INTEROP_FATAL("One of the branches for backgroundColor_buf_ has to be chosen through deserialisation.");
         }
+        backgroundColor_buf.value = static_cast<Ark_ResourceColor>(backgroundColor_buf_);
     }
-    const auto value_radius = value.radius;
-    Ark_Int32 value_radius_type = INTEROP_RUNTIME_UNDEFINED;
-    value_radius_type = runtimeType(value_radius);
-    valueSerializer.writeInt8(value_radius_type);
-    if ((value_radius_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_radius_value = value_radius.value;
-        Ark_Int32 value_radius_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_radius_value_type = value_radius_value.selector;
-        if (value_radius_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_radius_value_0 = value_radius_value.value0;
-            valueSerializer.writeString(value_radius_value_0);
+    value.backgroundColor = backgroundColor_buf;
+    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BlurStyle backgroundBlurStyle_buf = {};
+    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+    }
+    value.backgroundBlurStyle = backgroundBlurStyle_buf;
+    const auto backgroundBlurStyleOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions_buf = {};
+    backgroundBlurStyleOptions_buf.tag = backgroundBlurStyleOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundBlurStyleOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundBlurStyleOptions_buf.value = BackgroundBlurStyleOptions_serializer::read(valueDeserializer);
+    }
+    value.backgroundBlurStyleOptions = backgroundBlurStyleOptions_buf;
+    const auto backgroundEffect_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_BackgroundEffectOptions backgroundEffect_buf = {};
+    backgroundEffect_buf.tag = backgroundEffect_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((backgroundEffect_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        backgroundEffect_buf.value = BackgroundEffectOptions_serializer::read(valueDeserializer);
+    }
+    value.backgroundEffect = backgroundEffect_buf;
+    const auto onDidAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDidAppear_buf = {};
+    onDidAppear_buf.tag = onDidAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDidAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onDidAppear = onDidAppear_buf;
+    const auto onDidDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onDidDisappear_buf = {};
+    onDidDisappear_buf.tag = onDidDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onDidDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onDidDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onDidDisappear = onDidDisappear_buf;
+    const auto onWillAppear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillAppear_buf = {};
+    onWillAppear_buf.tag = onWillAppear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillAppear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillAppear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onWillAppear = onWillAppear_buf;
+    const auto onWillDisappear_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Callback_Void onWillDisappear_buf = {};
+    onWillDisappear_buf.tag = onWillDisappear_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onWillDisappear_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        onWillDisappear_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
+    }
+    value.onWillDisappear = onWillDisappear_buf;
+    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
+    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
+        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
+        shadow_buf_.selector = shadow_buf__selector;
+        if (shadow_buf__selector == 0) {
+            shadow_buf_.selector = 0;
+            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
         }
-        else if (value_radius_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_radius_value_1 = value_radius_value.value1;
-            valueSerializer.writeNumber(value_radius_value_1);
+        else if (shadow_buf__selector == 1) {
+            shadow_buf_.selector = 1;
+            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
         }
-        else if (value_radius_value_type == 2) {
-            valueSerializer.writeInt8(2);
-            const auto value_radius_value_2 = value_radius_value.value2;
-            Resource_serializer::write(valueSerializer, value_radius_value_2);
+        else {
+            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
         }
+        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
     }
-    const auto value_shadow = value.shadow;
-    Ark_Int32 value_shadow_type = INTEROP_RUNTIME_UNDEFINED;
-    value_shadow_type = runtimeType(value_shadow);
-    valueSerializer.writeInt8(value_shadow_type);
-    if ((value_shadow_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_shadow_value = value_shadow.value;
-        Ark_Int32 value_shadow_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_shadow_value_type = value_shadow_value.selector;
-        if (value_shadow_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_shadow_value_0 = value_shadow_value.value0;
-            ShadowOptions_serializer::write(valueSerializer, value_shadow_value_0);
-        }
-        else if (value_shadow_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_shadow_value_1 = value_shadow_value.value1;
-            valueSerializer.writeInt32(static_cast<Ark_ShadowStyle>(value_shadow_value_1));
-        }
+    value.shadow = shadow_buf;
+    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHoverMode_buf = {};
+    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableHoverMode_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_backgroundBlurStyle = value.backgroundBlurStyle;
-    Ark_Int32 value_backgroundBlurStyle_type = INTEROP_RUNTIME_UNDEFINED;
-    value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle);
-    valueSerializer.writeInt8(value_backgroundBlurStyle_type);
-    if ((value_backgroundBlurStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_backgroundBlurStyle_value = value_backgroundBlurStyle.value;
-        valueSerializer.writeInt32(static_cast<Ark_BlurStyle>(value_backgroundBlurStyle_value));
+    value.enableHoverMode = enableHoverMode_buf;
+    const auto hoverModeArea_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_HoverModeAreaType hoverModeArea_buf = {};
+    hoverModeArea_buf.tag = hoverModeArea_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((hoverModeArea_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        hoverModeArea_buf.value = static_cast<Ark_HoverModeAreaType>(valueDeserializer.readInt32());
     }
-    const auto value_transition = value.transition;
-    Ark_Int32 value_transition_type = INTEROP_RUNTIME_UNDEFINED;
-    value_transition_type = runtimeType(value_transition);
-    valueSerializer.writeInt8(value_transition_type);
-    if ((value_transition_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_transition_value = value_transition.value;
-        TransitionEffect_serializer::write(valueSerializer, value_transition_value);
+    value.hoverModeArea = hoverModeArea_buf;
+    const auto enableHapticFeedback_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Boolean enableHapticFeedback_buf = {};
+    enableHapticFeedback_buf.tag = enableHapticFeedback_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((enableHapticFeedback_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    {
+        enableHapticFeedback_buf.value = valueDeserializer.readBoolean();
     }
-    const auto value_onWillDismiss = value.onWillDismiss;
-    Ark_Int32 value_onWillDismiss_type = INTEROP_RUNTIME_UNDEFINED;
-    value_onWillDismiss_type = runtimeType(value_onWillDismiss);
-    valueSerializer.writeInt8(value_onWillDismiss_type);
-    if ((value_onWillDismiss_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_onWillDismiss_value = value_onWillDismiss.value;
-        Ark_Int32 value_onWillDismiss_value_type = INTEROP_RUNTIME_UNDEFINED;
-        value_onWillDismiss_value_type = value_onWillDismiss_value.selector;
-        if (value_onWillDismiss_value_type == 0) {
-            valueSerializer.writeInt8(0);
-            const auto value_onWillDismiss_value_0 = value_onWillDismiss_value.value0;
-            valueSerializer.writeBoolean(value_onWillDismiss_value_0);
-        }
-        else if (value_onWillDismiss_value_type == 1) {
-            valueSerializer.writeInt8(1);
-            const auto value_onWillDismiss_value_1 = value_onWillDismiss_value.value1;
-            valueSerializer.writeCallbackResource(value_onWillDismiss_value_1.resource);
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.call));
-            valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onWillDismiss_value_1.callSync));
-        }
+    value.enableHapticFeedback = enableHapticFeedback_buf;
+    return value;
+}
+inline void RichEditorImageSpanOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        valueSerializer.writeNumber(value_offset_value);
     }
-    const auto value_enableHoverMode = value.enableHoverMode;
-    Ark_Int32 value_enableHoverMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_enableHoverMode_type = runtimeType(value_enableHoverMode);
-    valueSerializer.writeInt8(value_enableHoverMode_type);
-    if ((value_enableHoverMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_enableHoverMode_value = value_enableHoverMode.value;
-        valueSerializer.writeBoolean(value_enableHoverMode_value);
+    const auto value_imageStyle = value.imageStyle;
+    Ark_Int32 value_imageStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_imageStyle_type = runtimeType(value_imageStyle);
+    valueSerializer.writeInt8(value_imageStyle_type);
+    if ((value_imageStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_imageStyle_value = value_imageStyle.value;
+        RichEditorImageSpanStyle_serializer::write(valueSerializer, value_imageStyle_value);
     }
-    const auto value_followTransformOfTarget = value.followTransformOfTarget;
-    Ark_Int32 value_followTransformOfTarget_type = INTEROP_RUNTIME_UNDEFINED;
-    value_followTransformOfTarget_type = runtimeType(value_followTransformOfTarget);
-    valueSerializer.writeInt8(value_followTransformOfTarget_type);
-    if ((value_followTransformOfTarget_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_followTransformOfTarget_value = value_followTransformOfTarget.value;
-        valueSerializer.writeBoolean(value_followTransformOfTarget_value);
+    const auto value_gesture = value.gesture;
+    Ark_Int32 value_gesture_type = INTEROP_RUNTIME_UNDEFINED;
+    value_gesture_type = runtimeType(value_gesture);
+    valueSerializer.writeInt8(value_gesture_type);
+    if ((value_gesture_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_gesture_value = value_gesture.value;
+        RichEditorGesture_serializer::write(valueSerializer, value_gesture_value);
     }
-    const auto value_keyboardAvoidMode = value.keyboardAvoidMode;
-    Ark_Int32 value_keyboardAvoidMode_type = INTEROP_RUNTIME_UNDEFINED;
-    value_keyboardAvoidMode_type = runtimeType(value_keyboardAvoidMode);
-    valueSerializer.writeInt8(value_keyboardAvoidMode_type);
-    if ((value_keyboardAvoidMode_type) != (INTEROP_RUNTIME_UNDEFINED)) {
-        const auto value_keyboardAvoidMode_value = value_keyboardAvoidMode.value;
-        valueSerializer.writeInt32(static_cast<Ark_KeyboardAvoidMode>(value_keyboardAvoidMode_value));
+    const auto value_onHover = value.onHover;
+    Ark_Int32 value_onHover_type = INTEROP_RUNTIME_UNDEFINED;
+    value_onHover_type = runtimeType(value_onHover);
+    valueSerializer.writeInt8(value_onHover_type);
+    if ((value_onHover_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_onHover_value = value_onHover.value;
+        valueSerializer.writeCallbackResource(value_onHover_value.resource);
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHover_value.call));
+        valueSerializer.writePointer(reinterpret_cast<Ark_NativePointer>(value_onHover_value.callSync));
     }
 }
-inline Ark_PopupOptions PopupOptions_serializer::read(DeserializerBase& buffer)
+inline Ark_RichEditorImageSpanOptions RichEditorImageSpanOptions_serializer::read(DeserializerBase& buffer)
 {
-    Ark_PopupOptions value = {};
+    Ark_RichEditorImageSpanOptions value = {};
     DeserializerBase& valueDeserializer = buffer;
-    value.message = static_cast<Ark_String>(valueDeserializer.readString());
-    const auto placement_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Placement placement_buf = {};
-    placement_buf.tag = placement_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((placement_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Number offset_buf = {};
+    offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        placement_buf.value = static_cast<Ark_Placement>(valueDeserializer.readInt32());
+        offset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
-    value.placement = placement_buf;
-    const auto primaryButton_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupButton primaryButton_buf = {};
-    primaryButton_buf.tag = primaryButton_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((primaryButton_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.offset = offset_buf;
+    const auto imageStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorImageSpanStyle imageStyle_buf = {};
+    imageStyle_buf.tag = imageStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((imageStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        primaryButton_buf.value = PopupButton_serializer::read(valueDeserializer);
+        imageStyle_buf.value = RichEditorImageSpanStyle_serializer::read(valueDeserializer);
     }
-    value.primaryButton = primaryButton_buf;
-    const auto secondaryButton_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupButton secondaryButton_buf = {};
-    secondaryButton_buf.tag = secondaryButton_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((secondaryButton_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.imageStyle = imageStyle_buf;
+    const auto gesture_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorGesture gesture_buf = {};
+    gesture_buf.tag = gesture_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((gesture_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        secondaryButton_buf.value = PopupButton_serializer::read(valueDeserializer);
+        gesture_buf.value = RichEditorGesture_serializer::read(valueDeserializer);
     }
-    value.secondaryButton = secondaryButton_buf;
-    const auto onStateChange_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupStateChangeCallback onStateChange_buf = {};
-    onStateChange_buf.tag = onStateChange_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onStateChange_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.gesture = gesture_buf;
+    const auto onHover_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_OnHoverCallback onHover_buf = {};
+    onHover_buf.tag = onHover_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((onHover_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        onStateChange_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_PopupStateChangeCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_PopupStateChangeParam event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_PopupStateChangeCallback))))};
+        onHover_buf.value = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_Boolean status, const Ark_HoverEvent event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_OnHoverCallback)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_Boolean status, const Ark_HoverEvent event)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_OnHoverCallback))))};
     }
-    value.onStateChange = onStateChange_buf;
-    const auto arrowOffset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length arrowOffset_buf = {};
-    arrowOffset_buf.tag = arrowOffset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowOffset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowOffset_buf__selector = valueDeserializer.readInt8();
-        Ark_Length arrowOffset_buf_ = {};
-        arrowOffset_buf_.selector = arrowOffset_buf__selector;
-        if (arrowOffset_buf__selector == 0) {
-            arrowOffset_buf_.selector = 0;
-            arrowOffset_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowOffset_buf__selector == 1) {
-            arrowOffset_buf_.selector = 1;
-            arrowOffset_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowOffset_buf__selector == 2) {
-            arrowOffset_buf_.selector = 2;
-            arrowOffset_buf_.value2 = Resource_serializer::read(valueDeserializer);
+    value.onHover = onHover_buf;
+    return value;
+}
+inline void RichEditorImageSpanResult_serializer::write(SerializerBase& buffer, Ark_RichEditorImageSpanResult value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_spanPosition = value.spanPosition;
+    RichEditorSpanPosition_serializer::write(valueSerializer, value_spanPosition);
+    const auto value_valuePixelMap = value.valuePixelMap;
+    Ark_Int32 value_valuePixelMap_type = INTEROP_RUNTIME_UNDEFINED;
+    value_valuePixelMap_type = runtimeType(value_valuePixelMap);
+    valueSerializer.writeInt8(value_valuePixelMap_type);
+    if ((value_valuePixelMap_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_valuePixelMap_value = value_valuePixelMap.value;
+        image_PixelMap_serializer::write(valueSerializer, value_valuePixelMap_value);
+    }
+    const auto value_valueResourceStr = value.valueResourceStr;
+    Ark_Int32 value_valueResourceStr_type = INTEROP_RUNTIME_UNDEFINED;
+    value_valueResourceStr_type = runtimeType(value_valueResourceStr);
+    valueSerializer.writeInt8(value_valueResourceStr_type);
+    if ((value_valueResourceStr_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_valueResourceStr_value = value_valueResourceStr.value;
+        Ark_Int32 value_valueResourceStr_value_type = INTEROP_RUNTIME_UNDEFINED;
+        value_valueResourceStr_value_type = value_valueResourceStr_value.selector;
+        if (value_valueResourceStr_value_type == 0) {
+            valueSerializer.writeInt8(0);
+            const auto value_valueResourceStr_value_0 = value_valueResourceStr_value.value0;
+            valueSerializer.writeString(value_valueResourceStr_value_0);
         }
-        else {
-            INTEROP_FATAL("One of the branches for arrowOffset_buf_ has to be chosen through deserialisation.");
+        else if (value_valueResourceStr_value_type == 1) {
+            valueSerializer.writeInt8(1);
+            const auto value_valueResourceStr_value_1 = value_valueResourceStr_value.value1;
+            Resource_serializer::write(valueSerializer, value_valueResourceStr_value_1);
         }
-        arrowOffset_buf.value = static_cast<Ark_Length>(arrowOffset_buf_);
     }
-    value.arrowOffset = arrowOffset_buf;
-    const auto showInSubWindow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean showInSubWindow_buf = {};
-    showInSubWindow_buf.tag = showInSubWindow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((showInSubWindow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto value_imageStyle = value.imageStyle;
+    RichEditorImageSpanStyleResult_serializer::write(valueSerializer, value_imageStyle);
+    const auto value_offsetInSpan = value.offsetInSpan;
+    const auto value_offsetInSpan_0 = value_offsetInSpan.value0;
+    valueSerializer.writeNumber(value_offsetInSpan_0);
+    const auto value_offsetInSpan_1 = value_offsetInSpan.value1;
+    valueSerializer.writeNumber(value_offsetInSpan_1);
+}
+inline Ark_RichEditorImageSpanResult RichEditorImageSpanResult_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorImageSpanResult value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.spanPosition = RichEditorSpanPosition_serializer::read(valueDeserializer);
+    const auto valuePixelMap_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_image_PixelMap valuePixelMap_buf = {};
+    valuePixelMap_buf.tag = valuePixelMap_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((valuePixelMap_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        showInSubWindow_buf.value = valueDeserializer.readBoolean();
+        valuePixelMap_buf.value = static_cast<Ark_image_PixelMap>(image_PixelMap_serializer::read(valueDeserializer));
     }
-    value.showInSubWindow = showInSubWindow_buf;
-    const auto mask_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_PopupMaskType mask_buf = {};
-    mask_buf.tag = mask_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((mask_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.valuePixelMap = valuePixelMap_buf;
+    const auto valueResourceStr_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_ResourceStr valueResourceStr_buf = {};
+    valueResourceStr_buf.tag = valueResourceStr_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((valueResourceStr_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 mask_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_PopupMaskType mask_buf_ = {};
-        mask_buf_.selector = mask_buf__selector;
-        if (mask_buf__selector == 0) {
-            mask_buf_.selector = 0;
-            mask_buf_.value0 = valueDeserializer.readBoolean();
+        const Ark_Int8 valueResourceStr_buf__selector = valueDeserializer.readInt8();
+        Ark_ResourceStr valueResourceStr_buf_ = {};
+        valueResourceStr_buf_.selector = valueResourceStr_buf__selector;
+        if (valueResourceStr_buf__selector == 0) {
+            valueResourceStr_buf_.selector = 0;
+            valueResourceStr_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
         }
-        else if (mask_buf__selector == 1) {
-            mask_buf_.selector = 1;
-            mask_buf_.value1 = PopupMaskType_serializer::read(valueDeserializer);
+        else if (valueResourceStr_buf__selector == 1) {
+            valueResourceStr_buf_.selector = 1;
+            valueResourceStr_buf_.value1 = Resource_serializer::read(valueDeserializer);
         }
         else {
-            INTEROP_FATAL("One of the branches for mask_buf_ has to be chosen through deserialisation.");
+            INTEROP_FATAL("One of the branches for valueResourceStr_buf_ has to be chosen through deserialisation.");
         }
-        mask_buf.value = static_cast<Ark_Union_Boolean_PopupMaskType>(mask_buf_);
+        valueResourceStr_buf.value = static_cast<Ark_ResourceStr>(valueResourceStr_buf_);
     }
-    value.mask = mask_buf;
-    const auto messageOptions_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_PopupMessageOptions messageOptions_buf = {};
-    messageOptions_buf.tag = messageOptions_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((messageOptions_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        messageOptions_buf.value = PopupMessageOptions_serializer::read(valueDeserializer);
+    value.valueResourceStr = valueResourceStr_buf;
+    value.imageStyle = RichEditorImageSpanStyleResult_serializer::read(valueDeserializer);
+    Ark_Tuple_Number_Number offsetInSpan_buf = {};
+    offsetInSpan_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    offsetInSpan_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.offsetInSpan = offsetInSpan_buf;
+    return value;
+}
+inline void RichEditorTextSpanOptions_serializer::write(SerializerBase& buffer, Ark_RichEditorTextSpanOptions value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_offset = value.offset;
+    Ark_Int32 value_offset_type = INTEROP_RUNTIME_UNDEFINED;
+    value_offset_type = runtimeType(value_offset);
+    valueSerializer.writeInt8(value_offset_type);
+    if ((value_offset_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_offset_value = value_offset.value;
+        valueSerializer.writeNumber(value_offset_value);
     }
-    value.messageOptions = messageOptions_buf;
-    const auto targetSpace_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Length targetSpace_buf = {};
-    targetSpace_buf.tag = targetSpace_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((targetSpace_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 targetSpace_buf__selector = valueDeserializer.readInt8();
-        Ark_Length targetSpace_buf_ = {};
-        targetSpace_buf_.selector = targetSpace_buf__selector;
-        if (targetSpace_buf__selector == 0) {
-            targetSpace_buf_.selector = 0;
-            targetSpace_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (targetSpace_buf__selector == 1) {
-            targetSpace_buf_.selector = 1;
-            targetSpace_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (targetSpace_buf__selector == 2) {
-            targetSpace_buf_.selector = 2;
-            targetSpace_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for targetSpace_buf_ has to be chosen through deserialisation.");
-        }
-        targetSpace_buf.value = static_cast<Ark_Length>(targetSpace_buf_);
+    const auto value_style = value.style;
+    Ark_Int32 value_style_type = INTEROP_RUNTIME_UNDEFINED;
+    value_style_type = runtimeType(value_style);
+    valueSerializer.writeInt8(value_style_type);
+    if ((value_style_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_style_value = value_style.value;
+        RichEditorTextStyle_serializer::write(valueSerializer, value_style_value);
+    }
+    const auto value_paragraphStyle = value.paragraphStyle;
+    Ark_Int32 value_paragraphStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_paragraphStyle_type = runtimeType(value_paragraphStyle);
+    valueSerializer.writeInt8(value_paragraphStyle_type);
+    if ((value_paragraphStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_paragraphStyle_value = value_paragraphStyle.value;
+        RichEditorParagraphStyle_serializer::write(valueSerializer, value_paragraphStyle_value);
     }
-    value.targetSpace = targetSpace_buf;
-    const auto enableArrow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableArrow_buf = {};
-    enableArrow_buf.tag = enableArrow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableArrow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        enableArrow_buf.value = valueDeserializer.readBoolean();
+    const auto value_gesture = value.gesture;
+    Ark_Int32 value_gesture_type = INTEROP_RUNTIME_UNDEFINED;
+    value_gesture_type = runtimeType(value_gesture);
+    valueSerializer.writeInt8(value_gesture_type);
+    if ((value_gesture_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_gesture_value = value_gesture.value;
+        RichEditorGesture_serializer::write(valueSerializer, value_gesture_value);
     }
-    value.enableArrow = enableArrow_buf;
+    const auto value_urlStyle = value.urlStyle;
+    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_urlStyle_type = runtimeType(value_urlStyle);
+    valueSerializer.writeInt8(value_urlStyle_type);
+    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_urlStyle_value = value_urlStyle.value;
+        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
+    }
+}
+inline Ark_RichEditorTextSpanOptions RichEditorTextSpanOptions_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorTextSpanOptions value = {};
+    DeserializerBase& valueDeserializer = buffer;
     const auto offset_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Position offset_buf = {};
+    Opt_Number offset_buf = {};
     offset_buf.tag = offset_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
     if ((offset_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        offset_buf.value = Position_serializer::read(valueDeserializer);
+        offset_buf.value = static_cast<Ark_Number>(valueDeserializer.readNumber());
     }
     value.offset = offset_buf;
-    const auto popupColor_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Color_String_Resource_Number popupColor_buf = {};
-    popupColor_buf.tag = popupColor_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((popupColor_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    const auto style_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorTextStyle style_buf = {};
+    style_buf.tag = style_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((style_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 popupColor_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Color_String_Resource_Number popupColor_buf_ = {};
-        popupColor_buf_.selector = popupColor_buf__selector;
-        if (popupColor_buf__selector == 0) {
-            popupColor_buf_.selector = 0;
-            popupColor_buf_.value0 = static_cast<Ark_Color>(valueDeserializer.readInt32());
-        }
-        else if (popupColor_buf__selector == 1) {
-            popupColor_buf_.selector = 1;
-            popupColor_buf_.value1 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (popupColor_buf__selector == 2) {
-            popupColor_buf_.selector = 2;
-            popupColor_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else if (popupColor_buf__selector == 3) {
-            popupColor_buf_.selector = 3;
-            popupColor_buf_.value3 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for popupColor_buf_ has to be chosen through deserialisation.");
-        }
-        popupColor_buf.value = static_cast<Ark_Union_Color_String_Resource_Number>(popupColor_buf_);
+        style_buf.value = RichEditorTextStyle_serializer::read(valueDeserializer);
     }
-    value.popupColor = popupColor_buf;
-    const auto autoCancel_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean autoCancel_buf = {};
-    autoCancel_buf.tag = autoCancel_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((autoCancel_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.style = style_buf;
+    const auto paragraphStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorParagraphStyle paragraphStyle_buf = {};
+    paragraphStyle_buf.tag = paragraphStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((paragraphStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        autoCancel_buf.value = valueDeserializer.readBoolean();
+        paragraphStyle_buf.value = RichEditorParagraphStyle_serializer::read(valueDeserializer);
     }
-    value.autoCancel = autoCancel_buf;
-    const auto width_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension width_buf = {};
-    width_buf.tag = width_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((width_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.paragraphStyle = paragraphStyle_buf;
+    const auto gesture_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorGesture gesture_buf = {};
+    gesture_buf.tag = gesture_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((gesture_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 width_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension width_buf_ = {};
-        width_buf_.selector = width_buf__selector;
-        if (width_buf__selector == 0) {
-            width_buf_.selector = 0;
-            width_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (width_buf__selector == 1) {
-            width_buf_.selector = 1;
-            width_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (width_buf__selector == 2) {
-            width_buf_.selector = 2;
-            width_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for width_buf_ has to be chosen through deserialisation.");
-        }
-        width_buf.value = static_cast<Ark_Dimension>(width_buf_);
+        gesture_buf.value = RichEditorGesture_serializer::read(valueDeserializer);
     }
-    value.width = width_buf;
-    const auto arrowPointPosition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_ArrowPointPosition arrowPointPosition_buf = {};
-    arrowPointPosition_buf.tag = arrowPointPosition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowPointPosition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.gesture = gesture_buf;
+    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorUrlStyle urlStyle_buf = {};
+    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        arrowPointPosition_buf.value = static_cast<Ark_ArrowPointPosition>(valueDeserializer.readInt32());
+        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
     }
-    value.arrowPointPosition = arrowPointPosition_buf;
-    const auto arrowWidth_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowWidth_buf = {};
-    arrowWidth_buf.tag = arrowWidth_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowWidth_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowWidth_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowWidth_buf_ = {};
-        arrowWidth_buf_.selector = arrowWidth_buf__selector;
-        if (arrowWidth_buf__selector == 0) {
-            arrowWidth_buf_.selector = 0;
-            arrowWidth_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowWidth_buf__selector == 1) {
-            arrowWidth_buf_.selector = 1;
-            arrowWidth_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowWidth_buf__selector == 2) {
-            arrowWidth_buf_.selector = 2;
-            arrowWidth_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for arrowWidth_buf_ has to be chosen through deserialisation.");
-        }
-        arrowWidth_buf.value = static_cast<Ark_Dimension>(arrowWidth_buf_);
+    value.urlStyle = urlStyle_buf;
+    return value;
+}
+inline void RichEditorTextSpanResult_serializer::write(SerializerBase& buffer, Ark_RichEditorTextSpanResult value)
+{
+    SerializerBase& valueSerializer = buffer;
+    const auto value_spanPosition = value.spanPosition;
+    RichEditorSpanPosition_serializer::write(valueSerializer, value_spanPosition);
+    const auto value_value = value.value;
+    valueSerializer.writeString(value_value);
+    const auto value_textStyle = value.textStyle;
+    RichEditorTextStyleResult_serializer::write(valueSerializer, value_textStyle);
+    const auto value_offsetInSpan = value.offsetInSpan;
+    const auto value_offsetInSpan_0 = value_offsetInSpan.value0;
+    valueSerializer.writeNumber(value_offsetInSpan_0);
+    const auto value_offsetInSpan_1 = value_offsetInSpan.value1;
+    valueSerializer.writeNumber(value_offsetInSpan_1);
+    const auto value_symbolSpanStyle = value.symbolSpanStyle;
+    Ark_Int32 value_symbolSpanStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_symbolSpanStyle_type = runtimeType(value_symbolSpanStyle);
+    valueSerializer.writeInt8(value_symbolSpanStyle_type);
+    if ((value_symbolSpanStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_symbolSpanStyle_value = value_symbolSpanStyle.value;
+        RichEditorSymbolSpanStyle_serializer::write(valueSerializer, value_symbolSpanStyle_value);
     }
-    value.arrowWidth = arrowWidth_buf;
-    const auto arrowHeight_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension arrowHeight_buf = {};
-    arrowHeight_buf.tag = arrowHeight_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((arrowHeight_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 arrowHeight_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension arrowHeight_buf_ = {};
-        arrowHeight_buf_.selector = arrowHeight_buf__selector;
-        if (arrowHeight_buf__selector == 0) {
-            arrowHeight_buf_.selector = 0;
-            arrowHeight_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (arrowHeight_buf__selector == 1) {
-            arrowHeight_buf_.selector = 1;
-            arrowHeight_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (arrowHeight_buf__selector == 2) {
-            arrowHeight_buf_.selector = 2;
-            arrowHeight_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for arrowHeight_buf_ has to be chosen through deserialisation.");
-        }
-        arrowHeight_buf.value = static_cast<Ark_Dimension>(arrowHeight_buf_);
+    const auto value_valueResource = value.valueResource;
+    Ark_Int32 value_valueResource_type = INTEROP_RUNTIME_UNDEFINED;
+    value_valueResource_type = runtimeType(value_valueResource);
+    valueSerializer.writeInt8(value_valueResource_type);
+    if ((value_valueResource_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_valueResource_value = value_valueResource.value;
+        Resource_serializer::write(valueSerializer, value_valueResource_value);
     }
-    value.arrowHeight = arrowHeight_buf;
-    const auto radius_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Dimension radius_buf = {};
-    radius_buf.tag = radius_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((radius_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 radius_buf__selector = valueDeserializer.readInt8();
-        Ark_Dimension radius_buf_ = {};
-        radius_buf_.selector = radius_buf__selector;
-        if (radius_buf__selector == 0) {
-            radius_buf_.selector = 0;
-            radius_buf_.value0 = static_cast<Ark_String>(valueDeserializer.readString());
-        }
-        else if (radius_buf__selector == 1) {
-            radius_buf_.selector = 1;
-            radius_buf_.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
-        }
-        else if (radius_buf__selector == 2) {
-            radius_buf_.selector = 2;
-            radius_buf_.value2 = Resource_serializer::read(valueDeserializer);
-        }
-        else {
-            INTEROP_FATAL("One of the branches for radius_buf_ has to be chosen through deserialisation.");
-        }
-        radius_buf.value = static_cast<Ark_Dimension>(radius_buf_);
+    const auto value_paragraphStyle = value.paragraphStyle;
+    Ark_Int32 value_paragraphStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_paragraphStyle_type = runtimeType(value_paragraphStyle);
+    valueSerializer.writeInt8(value_paragraphStyle_type);
+    if ((value_paragraphStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_paragraphStyle_value = value_paragraphStyle.value;
+        RichEditorParagraphStyle_serializer::write(valueSerializer, value_paragraphStyle_value);
     }
-    value.radius = radius_buf;
-    const auto shadow_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_ShadowOptions_ShadowStyle shadow_buf = {};
-    shadow_buf.tag = shadow_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((shadow_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        const Ark_Int8 shadow_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_ShadowOptions_ShadowStyle shadow_buf_ = {};
-        shadow_buf_.selector = shadow_buf__selector;
-        if (shadow_buf__selector == 0) {
-            shadow_buf_.selector = 0;
-            shadow_buf_.value0 = ShadowOptions_serializer::read(valueDeserializer);
-        }
-        else if (shadow_buf__selector == 1) {
-            shadow_buf_.selector = 1;
-            shadow_buf_.value1 = static_cast<Ark_ShadowStyle>(valueDeserializer.readInt32());
-        }
-        else {
-            INTEROP_FATAL("One of the branches for shadow_buf_ has to be chosen through deserialisation.");
-        }
-        shadow_buf.value = static_cast<Ark_Union_ShadowOptions_ShadowStyle>(shadow_buf_);
+    const auto value_previewText = value.previewText;
+    Ark_Int32 value_previewText_type = INTEROP_RUNTIME_UNDEFINED;
+    value_previewText_type = runtimeType(value_previewText);
+    valueSerializer.writeInt8(value_previewText_type);
+    if ((value_previewText_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_previewText_value = value_previewText.value;
+        valueSerializer.writeString(value_previewText_value);
     }
-    value.shadow = shadow_buf;
-    const auto backgroundBlurStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_BlurStyle backgroundBlurStyle_buf = {};
-    backgroundBlurStyle_buf.tag = backgroundBlurStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((backgroundBlurStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-    {
-        backgroundBlurStyle_buf.value = static_cast<Ark_BlurStyle>(valueDeserializer.readInt32());
+    const auto value_urlStyle = value.urlStyle;
+    Ark_Int32 value_urlStyle_type = INTEROP_RUNTIME_UNDEFINED;
+    value_urlStyle_type = runtimeType(value_urlStyle);
+    valueSerializer.writeInt8(value_urlStyle_type);
+    if ((value_urlStyle_type) != (INTEROP_RUNTIME_UNDEFINED)) {
+        const auto value_urlStyle_value = value_urlStyle.value;
+        RichEditorUrlStyle_serializer::write(valueSerializer, value_urlStyle_value);
     }
-    value.backgroundBlurStyle = backgroundBlurStyle_buf;
-    const auto transition_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_TransitionEffect transition_buf = {};
-    transition_buf.tag = transition_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((transition_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+}
+inline Ark_RichEditorTextSpanResult RichEditorTextSpanResult_serializer::read(DeserializerBase& buffer)
+{
+    Ark_RichEditorTextSpanResult value = {};
+    DeserializerBase& valueDeserializer = buffer;
+    value.spanPosition = RichEditorSpanPosition_serializer::read(valueDeserializer);
+    value.value = static_cast<Ark_String>(valueDeserializer.readString());
+    value.textStyle = RichEditorTextStyleResult_serializer::read(valueDeserializer);
+    Ark_Tuple_Number_Number offsetInSpan_buf = {};
+    offsetInSpan_buf.value0 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    offsetInSpan_buf.value1 = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.offsetInSpan = offsetInSpan_buf;
+    const auto symbolSpanStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorSymbolSpanStyle symbolSpanStyle_buf = {};
+    symbolSpanStyle_buf.tag = symbolSpanStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((symbolSpanStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        transition_buf.value = static_cast<Ark_TransitionEffect>(TransitionEffect_serializer::read(valueDeserializer));
+        symbolSpanStyle_buf.value = RichEditorSymbolSpanStyle_serializer::read(valueDeserializer);
     }
-    value.transition = transition_buf;
-    const auto onWillDismiss_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf = {};
-    onWillDismiss_buf.tag = onWillDismiss_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((onWillDismiss_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.symbolSpanStyle = symbolSpanStyle_buf;
+    const auto valueResource_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_Resource valueResource_buf = {};
+    valueResource_buf.tag = valueResource_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((valueResource_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        const Ark_Int8 onWillDismiss_buf__selector = valueDeserializer.readInt8();
-        Ark_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss_buf_ = {};
-        onWillDismiss_buf_.selector = onWillDismiss_buf__selector;
-        if (onWillDismiss_buf__selector == 0) {
-            onWillDismiss_buf_.selector = 0;
-            onWillDismiss_buf_.value0 = valueDeserializer.readBoolean();
-        }
-        else if (onWillDismiss_buf__selector == 1) {
-            onWillDismiss_buf_.selector = 1;
-            onWillDismiss_buf_.value1 = {valueDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_DismissPopupAction_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_DismissPopupAction value0)>(valueDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_DismissPopupAction_Void))))};
-        }
-        else {
-            INTEROP_FATAL("One of the branches for onWillDismiss_buf_ has to be chosen through deserialisation.");
-        }
-        onWillDismiss_buf.value = static_cast<Ark_Union_Boolean_Callback_DismissPopupAction_Void>(onWillDismiss_buf_);
+        valueResource_buf.value = Resource_serializer::read(valueDeserializer);
     }
-    value.onWillDismiss = onWillDismiss_buf;
-    const auto enableHoverMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean enableHoverMode_buf = {};
-    enableHoverMode_buf.tag = enableHoverMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((enableHoverMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.valueResource = valueResource_buf;
+    const auto paragraphStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorParagraphStyle paragraphStyle_buf = {};
+    paragraphStyle_buf.tag = paragraphStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((paragraphStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        enableHoverMode_buf.value = valueDeserializer.readBoolean();
+        paragraphStyle_buf.value = RichEditorParagraphStyle_serializer::read(valueDeserializer);
     }
-    value.enableHoverMode = enableHoverMode_buf;
-    const auto followTransformOfTarget_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_Boolean followTransformOfTarget_buf = {};
-    followTransformOfTarget_buf.tag = followTransformOfTarget_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((followTransformOfTarget_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.paragraphStyle = paragraphStyle_buf;
+    const auto previewText_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_String previewText_buf = {};
+    previewText_buf.tag = previewText_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((previewText_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        followTransformOfTarget_buf.value = valueDeserializer.readBoolean();
+        previewText_buf.value = static_cast<Ark_String>(valueDeserializer.readString());
     }
-    value.followTransformOfTarget = followTransformOfTarget_buf;
-    const auto keyboardAvoidMode_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
-    Opt_KeyboardAvoidMode keyboardAvoidMode_buf = {};
-    keyboardAvoidMode_buf.tag = keyboardAvoidMode_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-    if ((keyboardAvoidMode_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+    value.previewText = previewText_buf;
+    const auto urlStyle_buf_runtimeType = static_cast<Ark_RuntimeType>(valueDeserializer.readInt8());
+    Opt_RichEditorUrlStyle urlStyle_buf = {};
+    urlStyle_buf.tag = urlStyle_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+    if ((urlStyle_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
     {
-        keyboardAvoidMode_buf.value = static_cast<Ark_KeyboardAvoidMode>(valueDeserializer.readInt32());
+        urlStyle_buf.value = RichEditorUrlStyle_serializer::read(valueDeserializer);
     }
-    value.keyboardAvoidMode = keyboardAvoidMode_buf;
+    value.urlStyle = urlStyle_buf;
     return value;
 }
-inline void TransitionEffect_serializer::write(SerializerBase& buffer, Ark_TransitionEffect value)
+inline void SpanStyle_serializer::write(SerializerBase& buffer, Ark_SpanStyle value)
 {
     SerializerBase& valueSerializer = buffer;
-    valueSerializer.writePointer(value);
+    const auto value_start = value.start;
+    valueSerializer.writeNumber(value_start);
+    const auto value_length = value.length;
+    valueSerializer.writeNumber(value_length);
+    const auto value_styledKey = value.styledKey;
+    valueSerializer.writeInt32(static_cast<Ark_StyledStringKey>(value_styledKey));
+    const auto value_styledValue = value.styledValue;
+    Ark_Int32 value_styledValue_type = INTEROP_RUNTIME_UNDEFINED;
+    value_styledValue_type = value_styledValue.selector;
+    if (value_styledValue_type == 0) {
+        valueSerializer.writeInt8(0);
+        const auto value_styledValue_0 = value_styledValue.value0;
+        TextStyle_serializer::write(valueSerializer, value_styledValue_0);
+    }
+    else if (value_styledValue_type == 1) {
+        valueSerializer.writeInt8(1);
+        const auto value_styledValue_1 = value_styledValue.value1;
+        DecorationStyle_serializer::write(valueSerializer, value_styledValue_1);
+    }
+    else if (value_styledValue_type == 2) {
+        valueSerializer.writeInt8(2);
+        const auto value_styledValue_2 = value_styledValue.value2;
+        BaselineOffsetStyle_serializer::write(valueSerializer, value_styledValue_2);
+    }
+    else if (value_styledValue_type == 3) {
+        valueSerializer.writeInt8(3);
+        const auto value_styledValue_3 = value_styledValue.value3;
+        LetterSpacingStyle_serializer::write(valueSerializer, value_styledValue_3);
+    }
+    else if (value_styledValue_type == 4) {
+        valueSerializer.writeInt8(4);
+        const auto value_styledValue_4 = value_styledValue.value4;
+        TextShadowStyle_serializer::write(valueSerializer, value_styledValue_4);
+    }
+    else if (value_styledValue_type == 5) {
+        valueSerializer.writeInt8(5);
+        const auto value_styledValue_5 = value_styledValue.value5;
+        GestureStyle_serializer::write(valueSerializer, value_styledValue_5);
+    }
+    else if (value_styledValue_type == 6) {
+        valueSerializer.writeInt8(6);
+        const auto value_styledValue_6 = value_styledValue.value6;
+        ImageAttachment_serializer::write(valueSerializer, value_styledValue_6);
+    }
+    else if (value_styledValue_type == 7) {
+        valueSerializer.writeInt8(7);
+        const auto value_styledValue_7 = value_styledValue.value7;
+        ParagraphStyle_serializer::write(valueSerializer, value_styledValue_7);
+    }
+    else if (value_styledValue_type == 8) {
+        valueSerializer.writeInt8(8);
+        const auto value_styledValue_8 = value_styledValue.value8;
+        LineHeightStyle_serializer::write(valueSerializer, value_styledValue_8);
+    }
+    else if (value_styledValue_type == 9) {
+        valueSerializer.writeInt8(9);
+        const auto value_styledValue_9 = value_styledValue.value9;
+        UrlStyle_serializer::write(valueSerializer, value_styledValue_9);
+    }
+    else if (value_styledValue_type == 10) {
+        valueSerializer.writeInt8(10);
+        const auto value_styledValue_10 = value_styledValue.value10;
+        CustomSpan_serializer::write(valueSerializer, value_styledValue_10);
+    }
+    else if (value_styledValue_type == 11) {
+        valueSerializer.writeInt8(11);
+        const auto value_styledValue_11 = value_styledValue.value11;
+        UserDataSpan_serializer::write(valueSerializer, value_styledValue_11);
+    }
+    else if (value_styledValue_type == 12) {
+        valueSerializer.writeInt8(12);
+        const auto value_styledValue_12 = value_styledValue.value12;
+        BackgroundColorStyle_serializer::write(valueSerializer, value_styledValue_12);
+    }
 }
-inline Ark_TransitionEffect TransitionEffect_serializer::read(DeserializerBase& buffer)
+inline Ark_SpanStyle SpanStyle_serializer::read(DeserializerBase& buffer)
 {
+    Ark_SpanStyle value = {};
     DeserializerBase& valueDeserializer = buffer;
-    Ark_NativePointer ptr = valueDeserializer.readPointer();
-    return static_cast<Ark_TransitionEffect>(ptr);
+    value.start = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.length = static_cast<Ark_Number>(valueDeserializer.readNumber());
+    value.styledKey = static_cast<Ark_StyledStringKey>(valueDeserializer.readInt32());
+    const Ark_Int8 styledValue_buf_selector = valueDeserializer.readInt8();
+    Ark_StyledStringValue styledValue_buf = {};
+    styledValue_buf.selector = styledValue_buf_selector;
+    if (styledValue_buf_selector == 0) {
+        styledValue_buf.selector = 0;
+        styledValue_buf.value0 = static_cast<Ark_TextStyle>(TextStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 1) {
+        styledValue_buf.selector = 1;
+        styledValue_buf.value1 = static_cast<Ark_DecorationStyle>(DecorationStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 2) {
+        styledValue_buf.selector = 2;
+        styledValue_buf.value2 = static_cast<Ark_BaselineOffsetStyle>(BaselineOffsetStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 3) {
+        styledValue_buf.selector = 3;
+        styledValue_buf.value3 = static_cast<Ark_LetterSpacingStyle>(LetterSpacingStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 4) {
+        styledValue_buf.selector = 4;
+        styledValue_buf.value4 = static_cast<Ark_TextShadowStyle>(TextShadowStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 5) {
+        styledValue_buf.selector = 5;
+        styledValue_buf.value5 = static_cast<Ark_GestureStyle>(GestureStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 6) {
+        styledValue_buf.selector = 6;
+        styledValue_buf.value6 = static_cast<Ark_ImageAttachment>(ImageAttachment_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 7) {
+        styledValue_buf.selector = 7;
+        styledValue_buf.value7 = static_cast<Ark_ParagraphStyle>(ParagraphStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 8) {
+        styledValue_buf.selector = 8;
+        styledValue_buf.value8 = static_cast<Ark_LineHeightStyle>(LineHeightStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 9) {
+        styledValue_buf.selector = 9;
+        styledValue_buf.value9 = static_cast<Ark_UrlStyle>(UrlStyle_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 10) {
+        styledValue_buf.selector = 10;
+        styledValue_buf.value10 = static_cast<Ark_CustomSpan>(CustomSpan_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 11) {
+        styledValue_buf.selector = 11;
+        styledValue_buf.value11 = static_cast<Ark_UserDataSpan>(UserDataSpan_serializer::read(valueDeserializer));
+    }
+    else if (styledValue_buf_selector == 12) {
+        styledValue_buf.selector = 12;
+        styledValue_buf.value12 = static_cast<Ark_BackgroundColorStyle>(BackgroundColorStyle_serializer::read(valueDeserializer));
+    }
+    else {
+        INTEROP_FATAL("One of the branches for styledValue_buf has to be chosen through deserialisation.");
+    }
+    value.styledValue = static_cast<Ark_StyledStringValue>(styledValue_buf);
+    return value;
 }
 
 #endif
diff --git a/arkoala-arkts/framework/native/src/generated/arkoala_api_generated.h b/arkoala-arkts/framework/native/src/generated/arkoala_api_generated.h
index 0b951ba467..f2b503b8cd 100644
--- a/arkoala-arkts/framework/native/src/generated/arkoala_api_generated.h
+++ b/arkoala-arkts/framework/native/src/generated/arkoala_api_generated.h
@@ -199,7 +199,7 @@ typedef struct InteropObject {
 // The only include allowed in this file! Do not add anything else ever.
 #include <stdint.h>
 
-#define GENERATED_ARKUI_FULL_API_VERSION 132
+#define GENERATED_ARKUI_FULL_API_VERSION 133
 #define GENERATED_ARKUI_NODE_API_VERSION GENERATED_ARKUI_FULL_API_VERSION
 
 #define GENERATED_ARKUI_BASIC_NODE_API_VERSION 1
@@ -300,6 +300,9 @@ typedef struct Opt_Buffer Opt_Buffer;
 typedef struct BuilderNodeOpsPeer BuilderNodeOpsPeer;
 typedef struct BuilderNodeOpsPeer* Ark_BuilderNodeOps;
 typedef struct Opt_BuilderNodeOps Opt_BuilderNodeOps;
+typedef struct CalendarControllerPeer CalendarControllerPeer;
+typedef struct CalendarControllerPeer* Ark_CalendarController;
+typedef struct Opt_CalendarController Opt_CalendarController;
 typedef struct CalendarPickerDialogPeer CalendarPickerDialogPeer;
 typedef struct CalendarPickerDialogPeer* Ark_CalendarPickerDialog;
 typedef struct Opt_CalendarPickerDialog Opt_CalendarPickerDialog;
@@ -840,6 +843,9 @@ typedef struct Ark_TimePickerResult Ark_TimePickerResult;
 typedef struct Opt_TimePickerResult Opt_TimePickerResult;
 typedef struct Ark_TouchTestInfo Ark_TouchTestInfo;
 typedef struct Opt_TouchTestInfo Opt_TouchTestInfo;
+typedef struct TransitionEffectPeer TransitionEffectPeer;
+typedef struct TransitionEffectPeer* Ark_TransitionEffect;
+typedef struct Opt_TransitionEffect Opt_TransitionEffect;
 typedef struct Ark_TranslateResult Ark_TranslateResult;
 typedef struct Opt_TranslateResult Opt_TranslateResult;
 typedef struct Ark_Tuple_Number_Number Ark_Tuple_Number_Number;
@@ -969,6 +975,8 @@ typedef struct Array_BarrierStyle Array_BarrierStyle;
 typedef struct Opt_Array_BarrierStyle Opt_Array_BarrierStyle;
 typedef struct Array_Buffer Array_Buffer;
 typedef struct Opt_Array_Buffer Opt_Array_Buffer;
+typedef struct Array_CalendarDay Array_CalendarDay;
+typedef struct Opt_Array_CalendarDay Opt_Array_CalendarDay;
 typedef struct Array_ColorStop Array_ColorStop;
 typedef struct Opt_Array_ColorStop Opt_Array_ColorStop;
 typedef struct Array_common2D_Point Array_common2D_Point;
@@ -1161,6 +1169,10 @@ typedef struct Callback_Boolean_Void Callback_Boolean_Void;
 typedef struct Opt_Callback_Boolean_Void Opt_Callback_Boolean_Void;
 typedef struct Callback_Buffer_Void Callback_Buffer_Void;
 typedef struct Opt_Callback_Buffer_Void Opt_Callback_Buffer_Void;
+typedef struct Callback_CalendarRequestedData_Void Callback_CalendarRequestedData_Void;
+typedef struct Opt_Callback_CalendarRequestedData_Void Opt_Callback_CalendarRequestedData_Void;
+typedef struct Callback_CalendarSelectedDate_Void Callback_CalendarSelectedDate_Void;
+typedef struct Opt_Callback_CalendarSelectedDate_Void Opt_Callback_CalendarSelectedDate_Void;
 typedef struct Callback_ClickEvent_LocationButtonOnClickResult_Void Callback_ClickEvent_LocationButtonOnClickResult_Void;
 typedef struct Opt_Callback_ClickEvent_LocationButtonOnClickResult_Void Opt_Callback_ClickEvent_LocationButtonOnClickResult_Void;
 typedef struct Callback_ClickEvent_PasteButtonOnClickResult_Void Callback_ClickEvent_PasteButtonOnClickResult_Void;
@@ -1762,6 +1774,8 @@ typedef struct AppearSymbolEffectPeer* Ark_AppearSymbolEffect;
 typedef struct Opt_AppearSymbolEffect Opt_AppearSymbolEffect;
 typedef struct Ark_ASTCResource Ark_ASTCResource;
 typedef struct Opt_ASTCResource Opt_ASTCResource;
+typedef struct Ark_AsymmetricTransitionOption Ark_AsymmetricTransitionOption;
+typedef struct Opt_AsymmetricTransitionOption Opt_AsymmetricTransitionOption;
 typedef struct Ark_AutoPlayOptions Ark_AutoPlayOptions;
 typedef struct Opt_AutoPlayOptions Opt_AutoPlayOptions;
 typedef struct Ark_BackgroundBrightnessOptions Ark_BackgroundBrightnessOptions;
@@ -1794,6 +1808,12 @@ typedef struct Ark_ButtonConfiguration Ark_ButtonConfiguration;
 typedef struct Opt_ButtonConfiguration Opt_ButtonConfiguration;
 typedef struct Ark_ButtonOptions Ark_ButtonOptions;
 typedef struct Opt_ButtonOptions Opt_ButtonOptions;
+typedef struct Ark_CalendarDay Ark_CalendarDay;
+typedef struct Opt_CalendarDay Opt_CalendarDay;
+typedef struct Ark_CalendarRequestedData Ark_CalendarRequestedData;
+typedef struct Opt_CalendarRequestedData Opt_CalendarRequestedData;
+typedef struct Ark_CalendarSelectedDate Ark_CalendarSelectedDate;
+typedef struct Opt_CalendarSelectedDate Opt_CalendarSelectedDate;
 typedef struct Ark_CancelButtonSymbolOptions Ark_CancelButtonSymbolOptions;
 typedef struct Opt_CancelButtonSymbolOptions Opt_CancelButtonSymbolOptions;
 typedef struct Ark_CaretOffset Ark_CaretOffset;
@@ -2068,6 +2088,8 @@ typedef struct Ark_MeasureResult Ark_MeasureResult;
 typedef struct Opt_MeasureResult Opt_MeasureResult;
 typedef struct Ark_MessageEvents Ark_MessageEvents;
 typedef struct Opt_MessageEvents Opt_MessageEvents;
+typedef struct Ark_MonthData Ark_MonthData;
+typedef struct Opt_MonthData Opt_MonthData;
 typedef struct Ark_MotionBlurAnchor Ark_MotionBlurAnchor;
 typedef struct Opt_MotionBlurAnchor Opt_MotionBlurAnchor;
 typedef struct Ark_MotionBlurOptions Ark_MotionBlurOptions;
@@ -2520,6 +2542,8 @@ typedef struct Ark_ButtonIconOptions Ark_ButtonIconOptions;
 typedef struct Opt_ButtonIconOptions Opt_ButtonIconOptions;
 typedef struct Ark_CalendarOptions Ark_CalendarOptions;
 typedef struct Opt_CalendarOptions Opt_CalendarOptions;
+typedef struct Ark_CalendarRequestedMonths Ark_CalendarRequestedMonths;
+typedef struct Opt_CalendarRequestedMonths Opt_CalendarRequestedMonths;
 typedef struct CanvasRendererPeer CanvasRendererPeer;
 typedef struct CanvasRendererPeer* Ark_CanvasRenderer;
 typedef struct Opt_CanvasRenderer Opt_CanvasRenderer;
@@ -2532,8 +2556,14 @@ typedef struct Ark_Colors Ark_Colors;
 typedef struct Opt_Colors Opt_Colors;
 typedef struct Ark_ComponentInfo Ark_ComponentInfo;
 typedef struct Opt_ComponentInfo Opt_ComponentInfo;
+typedef struct Ark_ContentCoverOptions Ark_ContentCoverOptions;
+typedef struct Opt_ContentCoverOptions Opt_ContentCoverOptions;
+typedef struct Ark_ContextMenuAnimationOptions Ark_ContextMenuAnimationOptions;
+typedef struct Opt_ContextMenuAnimationOptions Opt_ContextMenuAnimationOptions;
 typedef struct Ark_CopyEvent Ark_CopyEvent;
 typedef struct Opt_CopyEvent Opt_CopyEvent;
+typedef struct Ark_CurrentDayStyle Ark_CurrentDayStyle;
+typedef struct Opt_CurrentDayStyle Opt_CurrentDayStyle;
 typedef struct Ark_CutEvent Ark_CutEvent;
 typedef struct Opt_CutEvent Opt_CutEvent;
 typedef struct Ark_DataPanelShadowOptions Ark_DataPanelShadowOptions;
@@ -2624,6 +2654,8 @@ typedef struct Opt_NavigationMenuItem Opt_NavigationMenuItem;
 typedef struct NavigationTransitionProxyPeer NavigationTransitionProxyPeer;
 typedef struct NavigationTransitionProxyPeer* Ark_NavigationTransitionProxy;
 typedef struct Opt_NavigationTransitionProxy Opt_NavigationTransitionProxy;
+typedef struct Ark_NonCurrentDayStyle Ark_NonCurrentDayStyle;
+typedef struct Opt_NonCurrentDayStyle Opt_NonCurrentDayStyle;
 typedef struct OffscreenCanvasRenderingContext2DPeer OffscreenCanvasRenderingContext2DPeer;
 typedef struct OffscreenCanvasRenderingContext2DPeer* Ark_OffscreenCanvasRenderingContext2D;
 typedef struct Opt_OffscreenCanvasRenderingContext2D Opt_OffscreenCanvasRenderingContext2D;
@@ -2719,6 +2751,8 @@ typedef struct TextStylePeer* Ark_TextStyle;
 typedef struct Opt_TextStyle Opt_TextStyle;
 typedef struct Ark_TextStyleInterface Ark_TextStyleInterface;
 typedef struct Opt_TextStyleInterface Opt_TextStyleInterface;
+typedef struct Ark_TodayStyle Ark_TodayStyle;
+typedef struct Opt_TodayStyle Opt_TodayStyle;
 typedef struct Ark_ToolbarItem Ark_ToolbarItem;
 typedef struct Opt_ToolbarItem Opt_ToolbarItem;
 typedef struct Ark_Tuple_Dimension_Dimension Ark_Tuple_Dimension_Dimension;
@@ -2771,6 +2805,10 @@ typedef struct Ark_Union_TitleHeight_Length Ark_Union_TitleHeight_Length;
 typedef struct Opt_Union_TitleHeight_Length Opt_Union_TitleHeight_Length;
 typedef struct Ark_VideoOptions Ark_VideoOptions;
 typedef struct Opt_VideoOptions Opt_VideoOptions;
+typedef struct Ark_WeekStyle Ark_WeekStyle;
+typedef struct Opt_WeekStyle Opt_WeekStyle;
+typedef struct Ark_WorkStateStyle Ark_WorkStateStyle;
+typedef struct Opt_WorkStateStyle Opt_WorkStateStyle;
 typedef struct Ark_XComponentOptions Ark_XComponentOptions;
 typedef struct Opt_XComponentOptions Opt_XComponentOptions;
 typedef struct Ark_XComponentParameter Ark_XComponentParameter;
@@ -2994,8 +3032,12 @@ typedef struct Ark_CancelButtonOptions Ark_CancelButtonOptions;
 typedef struct Opt_CancelButtonOptions Opt_CancelButtonOptions;
 typedef struct Ark_CapsuleStyleOptions Ark_CapsuleStyleOptions;
 typedef struct Opt_CapsuleStyleOptions Opt_CapsuleStyleOptions;
+typedef struct Ark_ContextMenuOptions Ark_ContextMenuOptions;
+typedef struct Opt_ContextMenuOptions Opt_ContextMenuOptions;
 typedef struct Ark_CustomDialogControllerOptions Ark_CustomDialogControllerOptions;
 typedef struct Opt_CustomDialogControllerOptions Opt_CustomDialogControllerOptions;
+typedef struct Ark_CustomPopupOptions Ark_CustomPopupOptions;
+typedef struct Opt_CustomPopupOptions Opt_CustomPopupOptions;
 typedef struct Ark_DigitIndicator Ark_DigitIndicator;
 typedef struct Opt_DigitIndicator Opt_DigitIndicator;
 typedef struct Ark_EventTarget Ark_EventTarget;
@@ -3021,6 +3063,8 @@ typedef struct Opt_LayoutChild Opt_LayoutChild;
 typedef struct LongPressGestureEventPeer LongPressGestureEventPeer;
 typedef struct LongPressGestureEventPeer* Ark_LongPressGestureEvent;
 typedef struct Opt_LongPressGestureEvent Opt_LongPressGestureEvent;
+typedef struct Ark_MenuOptions Ark_MenuOptions;
+typedef struct Opt_MenuOptions Opt_MenuOptions;
 typedef struct Ark_MenuOutlineOptions Ark_MenuOutlineOptions;
 typedef struct Opt_MenuOutlineOptions Opt_MenuOutlineOptions;
 typedef struct MouseEventPeer MouseEventPeer;
@@ -3051,6 +3095,8 @@ typedef struct PinchGestureEventPeer* Ark_PinchGestureEvent;
 typedef struct Opt_PinchGestureEvent Opt_PinchGestureEvent;
 typedef struct Ark_PlaceholderStyle Ark_PlaceholderStyle;
 typedef struct Opt_PlaceholderStyle Opt_PlaceholderStyle;
+typedef struct Ark_PopupCommonOptions Ark_PopupCommonOptions;
+typedef struct Opt_PopupCommonOptions Opt_PopupCommonOptions;
 typedef struct Ark_PopupMessageOptions Ark_PopupMessageOptions;
 typedef struct Opt_PopupMessageOptions Opt_PopupMessageOptions;
 typedef struct Ark_ResizableOptions Ark_ResizableOptions;
@@ -3132,6 +3178,8 @@ typedef struct Ark_NativeEmbedDataInfo Ark_NativeEmbedDataInfo;
 typedef struct Opt_NativeEmbedDataInfo Opt_NativeEmbedDataInfo;
 typedef struct Ark_NativeEmbedTouchInfo Ark_NativeEmbedTouchInfo;
 typedef struct Opt_NativeEmbedTouchInfo Opt_NativeEmbedTouchInfo;
+typedef struct Ark_PopupOptions Ark_PopupOptions;
+typedef struct Opt_PopupOptions Opt_PopupOptions;
 typedef struct Ark_ResourceImageAttachmentOptions Ark_ResourceImageAttachmentOptions;
 typedef struct Opt_ResourceImageAttachmentOptions Opt_ResourceImageAttachmentOptions;
 typedef struct Ark_RichEditorImageSpanStyle Ark_RichEditorImageSpanStyle;
@@ -3158,6 +3206,8 @@ typedef struct Ark_TextPickerDialogOptions Ark_TextPickerDialogOptions;
 typedef struct Opt_TextPickerDialogOptions Opt_TextPickerDialogOptions;
 typedef struct Ark_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions Ark_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions;
 typedef struct Opt_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions Opt_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions;
+typedef struct Ark_Union_PopupOptions_CustomPopupOptions Ark_Union_PopupOptions_CustomPopupOptions;
+typedef struct Opt_Union_PopupOptions_CustomPopupOptions Opt_Union_PopupOptions_CustomPopupOptions;
 typedef struct Ark_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions Ark_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions;
 typedef struct Opt_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions Opt_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions;
 typedef struct Ark_Union_String_ImageAttachment_CustomSpan Ark_Union_String_ImageAttachment_CustomSpan;
@@ -3182,27 +3232,6 @@ typedef struct Ark_RichEditorSpan Ark_RichEditorSpan;
 typedef struct Opt_RichEditorSpan Opt_RichEditorSpan;
 typedef struct Ark_Union_ImageAttachmentInterface_Opt_AttachmentType Ark_Union_ImageAttachmentInterface_Opt_AttachmentType;
 typedef struct Opt_Union_ImageAttachmentInterface_Opt_AttachmentType Opt_Union_ImageAttachmentInterface_Opt_AttachmentType;
-typedef struct Ark_AsymmetricTransitionOption Ark_AsymmetricTransitionOption;
-typedef struct Opt_AsymmetricTransitionOption Opt_AsymmetricTransitionOption;
-typedef struct Ark_ContentCoverOptions Ark_ContentCoverOptions;
-typedef struct Opt_ContentCoverOptions Opt_ContentCoverOptions;
-typedef struct Ark_ContextMenuAnimationOptions Ark_ContextMenuAnimationOptions;
-typedef struct Opt_ContextMenuAnimationOptions Opt_ContextMenuAnimationOptions;
-typedef struct Ark_ContextMenuOptions Ark_ContextMenuOptions;
-typedef struct Opt_ContextMenuOptions Opt_ContextMenuOptions;
-typedef struct Ark_CustomPopupOptions Ark_CustomPopupOptions;
-typedef struct Opt_CustomPopupOptions Opt_CustomPopupOptions;
-typedef struct Ark_MenuOptions Ark_MenuOptions;
-typedef struct Opt_MenuOptions Opt_MenuOptions;
-typedef struct Ark_PopupCommonOptions Ark_PopupCommonOptions;
-typedef struct Opt_PopupCommonOptions Opt_PopupCommonOptions;
-typedef struct Ark_PopupOptions Ark_PopupOptions;
-typedef struct Opt_PopupOptions Opt_PopupOptions;
-typedef struct TransitionEffectPeer TransitionEffectPeer;
-typedef struct TransitionEffectPeer* Ark_TransitionEffect;
-typedef struct Opt_TransitionEffect Opt_TransitionEffect;
-typedef struct Ark_Union_PopupOptions_CustomPopupOptions Ark_Union_PopupOptions_CustomPopupOptions;
-typedef struct Opt_Union_PopupOptions_CustomPopupOptions Opt_Union_PopupOptions_CustomPopupOptions;
 typedef Ark_Object Ark_ContentModifier;
 typedef Opt_Object Opt_ContentModifier;
 typedef enum Ark_AccessibilityHoverType {
@@ -7052,6 +7081,10 @@ typedef struct Opt_BuilderNodeOps {
     Ark_Tag tag;
     Ark_BuilderNodeOps value;
 } Opt_BuilderNodeOps;
+typedef struct Opt_CalendarController {
+    Ark_Tag tag;
+    Ark_CalendarController value;
+} Opt_CalendarController;
 typedef struct Opt_CalendarPickerDialog {
     Ark_Tag tag;
     Ark_CalendarPickerDialog value;
@@ -8215,6 +8248,10 @@ typedef struct Opt_TouchTestInfo {
     Ark_Tag tag;
     Ark_TouchTestInfo value;
 } Opt_TouchTestInfo;
+typedef struct Opt_TransitionEffect {
+    Ark_Tag tag;
+    Ark_TransitionEffect value;
+} Opt_TransitionEffect;
 typedef struct Ark_TranslateResult {
     /* kind: Interface */
     Ark_Number x;
@@ -8724,6 +8761,15 @@ typedef struct Opt_Array_Buffer {
     Ark_Tag tag;
     Array_Buffer value;
 } Opt_Array_Buffer;
+typedef struct Array_CalendarDay {
+    /* kind: ContainerType */
+    Ark_CalendarDay* array;
+    Ark_Int32 length;
+} Array_CalendarDay;
+typedef struct Opt_Array_CalendarDay {
+    Ark_Tag tag;
+    Array_CalendarDay value;
+} Opt_Array_CalendarDay;
 typedef struct Array_ColorStop {
     /* kind: ContainerType */
     Ark_ColorStop* array;
@@ -9601,6 +9647,26 @@ typedef struct Opt_Callback_Buffer_Void {
     Ark_Tag tag;
     Callback_Buffer_Void value;
 } Opt_Callback_Buffer_Void;
+typedef struct Callback_CalendarRequestedData_Void {
+    /* kind: Callback */
+    Ark_CallbackResource resource;
+    void (*call)(const Ark_Int32 resourceId, const Ark_CalendarRequestedData event);
+    void (*callSync)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarRequestedData event);
+} Callback_CalendarRequestedData_Void;
+typedef struct Opt_Callback_CalendarRequestedData_Void {
+    Ark_Tag tag;
+    Callback_CalendarRequestedData_Void value;
+} Opt_Callback_CalendarRequestedData_Void;
+typedef struct Callback_CalendarSelectedDate_Void {
+    /* kind: Callback */
+    Ark_CallbackResource resource;
+    void (*call)(const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event);
+    void (*callSync)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event);
+} Callback_CalendarSelectedDate_Void;
+typedef struct Opt_Callback_CalendarSelectedDate_Void {
+    Ark_Tag tag;
+    Callback_CalendarSelectedDate_Void value;
+} Opt_Callback_CalendarSelectedDate_Void;
 typedef struct Callback_ClickEvent_LocationButtonOnClickResult_Void {
     /* kind: Callback */
     Ark_CallbackResource resource;
@@ -12587,6 +12653,15 @@ typedef struct Opt_ASTCResource {
     Ark_Tag tag;
     Ark_ASTCResource value;
 } Opt_ASTCResource;
+typedef struct Ark_AsymmetricTransitionOption {
+    /* kind: Interface */
+    Ark_TransitionEffect appear;
+    Ark_TransitionEffect disappear;
+} Ark_AsymmetricTransitionOption;
+typedef struct Opt_AsymmetricTransitionOption {
+    Ark_Tag tag;
+    Ark_AsymmetricTransitionOption value;
+} Opt_AsymmetricTransitionOption;
 typedef struct Ark_AutoPlayOptions {
     /* kind: Interface */
     Ark_Boolean stopWhenTouched;
@@ -12721,6 +12796,46 @@ typedef struct Opt_ButtonOptions {
     Ark_Tag tag;
     Ark_ButtonOptions value;
 } Opt_ButtonOptions;
+typedef struct Ark_CalendarDay {
+    /* kind: Interface */
+    Ark_Number index;
+    Ark_String lunarMonth;
+    Ark_String lunarDay;
+    Ark_String dayMark;
+    Ark_String dayMarkValue;
+    Ark_Number year;
+    Ark_Number month;
+    Ark_Number day;
+    Ark_Boolean isFirstOfLunar;
+    Ark_Boolean hasSchedule;
+    Ark_Boolean markLunarDay;
+} Ark_CalendarDay;
+typedef struct Opt_CalendarDay {
+    Ark_Tag tag;
+    Ark_CalendarDay value;
+} Opt_CalendarDay;
+typedef struct Ark_CalendarRequestedData {
+    /* kind: Interface */
+    Ark_Number year;
+    Ark_Number month;
+    Ark_Number currentYear;
+    Ark_Number currentMonth;
+    Ark_Number monthState;
+} Ark_CalendarRequestedData;
+typedef struct Opt_CalendarRequestedData {
+    Ark_Tag tag;
+    Ark_CalendarRequestedData value;
+} Opt_CalendarRequestedData;
+typedef struct Ark_CalendarSelectedDate {
+    /* kind: Interface */
+    Ark_Number year;
+    Ark_Number month;
+    Ark_Number day;
+} Ark_CalendarSelectedDate;
+typedef struct Opt_CalendarSelectedDate {
+    Ark_Tag tag;
+    Ark_CalendarSelectedDate value;
+} Opt_CalendarSelectedDate;
 typedef struct Ark_CancelButtonSymbolOptions {
     /* kind: Interface */
     Opt_CancelButtonStyle style;
@@ -13963,6 +14078,16 @@ typedef struct Opt_MessageEvents {
     Ark_Tag tag;
     Ark_MessageEvents value;
 } Opt_MessageEvents;
+typedef struct Ark_MonthData {
+    /* kind: Interface */
+    Ark_Number year;
+    Ark_Number month;
+    Array_CalendarDay data;
+} Ark_MonthData;
+typedef struct Opt_MonthData {
+    Ark_Tag tag;
+    Ark_MonthData value;
+} Opt_MonthData;
 typedef struct Ark_MotionBlurAnchor {
     /* kind: Interface */
     Ark_Number x;
@@ -16358,6 +16483,18 @@ typedef struct Opt_CalendarOptions {
     Ark_Tag tag;
     Ark_CalendarOptions value;
 } Opt_CalendarOptions;
+typedef struct Ark_CalendarRequestedMonths {
+    /* kind: Interface */
+    Ark_CalendarSelectedDate date;
+    Ark_MonthData currentData;
+    Ark_MonthData preData;
+    Ark_MonthData nextData;
+    Opt_CalendarController controller;
+} Ark_CalendarRequestedMonths;
+typedef struct Opt_CalendarRequestedMonths {
+    Ark_Tag tag;
+    Ark_CalendarRequestedMonths value;
+} Opt_CalendarRequestedMonths;
 typedef struct Opt_CanvasRenderer {
     Ark_Tag tag;
     Ark_CanvasRenderer value;
@@ -16450,6 +16587,31 @@ typedef struct Opt_ComponentInfo {
     Ark_Tag tag;
     Ark_ComponentInfo value;
 } Opt_ComponentInfo;
+typedef struct Ark_ContentCoverOptions {
+    /* kind: Interface */
+    Opt_ResourceColor backgroundColor;
+    Opt_Callback_Void onAppear;
+    Opt_Callback_Void onDisappear;
+    Opt_Callback_Void onWillAppear;
+    Opt_Callback_Void onWillDisappear;
+    Opt_ModalTransition modalTransition;
+    Opt_Callback_DismissContentCoverAction_Void onWillDismiss;
+    Opt_TransitionEffect transition;
+} Ark_ContentCoverOptions;
+typedef struct Opt_ContentCoverOptions {
+    Ark_Tag tag;
+    Ark_ContentCoverOptions value;
+} Opt_ContentCoverOptions;
+typedef struct Ark_ContextMenuAnimationOptions {
+    /* kind: Interface */
+    Opt_AnimationNumberRange scale;
+    Opt_TransitionEffect transition;
+    Opt_AnimationNumberRange hoverScale;
+} Ark_ContextMenuAnimationOptions;
+typedef struct Opt_ContextMenuAnimationOptions {
+    Ark_Tag tag;
+    Ark_ContextMenuAnimationOptions value;
+} Opt_ContextMenuAnimationOptions;
 typedef struct Ark_CopyEvent {
     /* kind: Interface */
     Opt_VoidCallback preventDefault;
@@ -16458,6 +16620,36 @@ typedef struct Opt_CopyEvent {
     Ark_Tag tag;
     Ark_CopyEvent value;
 } Opt_CopyEvent;
+typedef struct Ark_CurrentDayStyle {
+    /* kind: Interface */
+    Opt_ResourceColor dayColor;
+    Opt_ResourceColor lunarColor;
+    Opt_ResourceColor markLunarColor;
+    Opt_Number dayFontSize;
+    Opt_Number lunarDayFontSize;
+    Opt_Number dayHeight;
+    Opt_Number dayWidth;
+    Opt_Number gregorianCalendarHeight;
+    Opt_Number dayYAxisOffset;
+    Opt_Number lunarDayYAxisOffset;
+    Opt_Number underscoreXAxisOffset;
+    Opt_Number underscoreYAxisOffset;
+    Opt_Number scheduleMarkerXAxisOffset;
+    Opt_Number scheduleMarkerYAxisOffset;
+    Opt_Number colSpace;
+    Opt_Number dailyFiveRowSpace;
+    Opt_Number dailySixRowSpace;
+    Opt_Number lunarHeight;
+    Opt_Number underscoreWidth;
+    Opt_Number underscoreLength;
+    Opt_Number scheduleMarkerRadius;
+    Opt_Number boundaryRowOffset;
+    Opt_Number boundaryColOffset;
+} Ark_CurrentDayStyle;
+typedef struct Opt_CurrentDayStyle {
+    Ark_Tag tag;
+    Ark_CurrentDayStyle value;
+} Opt_CurrentDayStyle;
 typedef struct Ark_CutEvent {
     /* kind: Interface */
     Opt_VoidCallback preventDefault;
@@ -16912,6 +17104,17 @@ typedef struct Opt_NavigationTransitionProxy {
     Ark_Tag tag;
     Ark_NavigationTransitionProxy value;
 } Opt_NavigationTransitionProxy;
+typedef struct Ark_NonCurrentDayStyle {
+    /* kind: Interface */
+    Opt_ResourceColor nonCurrentMonthDayColor;
+    Opt_ResourceColor nonCurrentMonthLunarColor;
+    Opt_ResourceColor nonCurrentMonthWorkDayMarkColor;
+    Opt_ResourceColor nonCurrentMonthOffDayMarkColor;
+} Ark_NonCurrentDayStyle;
+typedef struct Opt_NonCurrentDayStyle {
+    Ark_Tag tag;
+    Ark_NonCurrentDayStyle value;
+} Opt_NonCurrentDayStyle;
 typedef struct Opt_OffscreenCanvasRenderingContext2D {
     Ark_Tag tag;
     Ark_OffscreenCanvasRenderingContext2D value;
@@ -17351,6 +17554,17 @@ typedef struct Opt_TextStyleInterface {
     Ark_Tag tag;
     Ark_TextStyleInterface value;
 } Opt_TextStyleInterface;
+typedef struct Ark_TodayStyle {
+    /* kind: Interface */
+    Opt_ResourceColor focusedDayColor;
+    Opt_ResourceColor focusedLunarColor;
+    Opt_ResourceColor focusedAreaBackgroundColor;
+    Opt_Number focusedAreaRadius;
+} Ark_TodayStyle;
+typedef struct Opt_TodayStyle {
+    Ark_Tag tag;
+    Ark_TodayStyle value;
+} Opt_TodayStyle;
 typedef struct Ark_ToolbarItem {
     /* kind: Interface */
     Ark_ResourceStr value;
@@ -17658,6 +17872,34 @@ typedef struct Opt_VideoOptions {
     Ark_Tag tag;
     Ark_VideoOptions value;
 } Opt_VideoOptions;
+typedef struct Ark_WeekStyle {
+    /* kind: Interface */
+    Opt_ResourceColor weekColor;
+    Opt_ResourceColor weekendDayColor;
+    Opt_ResourceColor weekendLunarColor;
+    Opt_Number weekFontSize;
+    Opt_Number weekHeight;
+    Opt_Number weekWidth;
+    Opt_Number weekAndDayRowSpace;
+} Ark_WeekStyle;
+typedef struct Opt_WeekStyle {
+    Ark_Tag tag;
+    Ark_WeekStyle value;
+} Opt_WeekStyle;
+typedef struct Ark_WorkStateStyle {
+    /* kind: Interface */
+    Opt_ResourceColor workDayMarkColor;
+    Opt_ResourceColor offDayMarkColor;
+    Opt_Number workDayMarkSize;
+    Opt_Number offDayMarkSize;
+    Opt_Number workStateWidth;
+    Opt_Number workStateHorizontalMovingDistance;
+    Opt_Number workStateVerticalMovingDistance;
+} Ark_WorkStateStyle;
+typedef struct Opt_WorkStateStyle {
+    Ark_Tag tag;
+    Ark_WorkStateStyle value;
+} Opt_WorkStateStyle;
 typedef struct Ark_XComponentOptions {
     /* kind: Interface */
     Ark_XComponentType type;
@@ -18953,6 +19195,35 @@ typedef struct Opt_CapsuleStyleOptions {
     Ark_Tag tag;
     Ark_CapsuleStyleOptions value;
 } Opt_CapsuleStyleOptions;
+typedef struct Ark_ContextMenuOptions {
+    /* kind: Interface */
+    Opt_Position offset;
+    Opt_Placement placement;
+    Opt_Boolean enableArrow;
+    Opt_Length arrowOffset;
+    Opt_Union_MenuPreviewMode_CustomBuilder preview;
+    Opt_BorderRadiusType previewBorderRadius;
+    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius;
+    Opt_Callback_Void onAppear;
+    Opt_Callback_Void onDisappear;
+    Opt_Callback_Void aboutToAppear;
+    Opt_Callback_Void aboutToDisappear;
+    Opt_Padding layoutRegionMargin;
+    Opt_ContextMenuAnimationOptions previewAnimationOptions;
+    Opt_ResourceColor backgroundColor;
+    Opt_BlurStyle backgroundBlurStyle;
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions;
+    Opt_BackgroundEffectOptions backgroundEffect;
+    Opt_TransitionEffect transition;
+    Opt_Boolean enableHoverMode;
+    Opt_Union_ResourceColor_EdgeColors outlineColor;
+    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth;
+    Opt_HapticFeedbackMode hapticFeedbackMode;
+} Ark_ContextMenuOptions;
+typedef struct Opt_ContextMenuOptions {
+    Ark_Tag tag;
+    Ark_ContextMenuOptions value;
+} Opt_ContextMenuOptions;
 typedef struct Ark_CustomDialogControllerOptions {
     /* kind: Interface */
     Ark_Union_CustomBuilder_ExtendableComponent builder;
@@ -18998,6 +19269,37 @@ typedef struct Opt_CustomDialogControllerOptions {
     Ark_Tag tag;
     Ark_CustomDialogControllerOptions value;
 } Opt_CustomDialogControllerOptions;
+typedef struct Ark_CustomPopupOptions {
+    /* kind: Interface */
+    CustomNodeBuilder builder;
+    Opt_Placement placement;
+    Opt_Union_Color_String_Resource_Number popupColor;
+    Opt_Boolean enableArrow;
+    Opt_Boolean autoCancel;
+    Opt_PopupStateChangeCallback onStateChange;
+    Opt_Length arrowOffset;
+    Opt_Boolean showInSubWindow;
+    Opt_Union_Boolean_PopupMaskType mask;
+    Opt_Length targetSpace;
+    Opt_Position offset;
+    Opt_Dimension width;
+    Opt_ArrowPointPosition arrowPointPosition;
+    Opt_Dimension arrowWidth;
+    Opt_Dimension arrowHeight;
+    Opt_Dimension radius;
+    Opt_Union_ShadowOptions_ShadowStyle shadow;
+    Opt_BlurStyle backgroundBlurStyle;
+    Opt_Boolean focusable;
+    Opt_TransitionEffect transition;
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
+    Opt_Boolean enableHoverMode;
+    Opt_Boolean followTransformOfTarget;
+    Opt_KeyboardAvoidMode keyboardAvoidMode;
+} Ark_CustomPopupOptions;
+typedef struct Opt_CustomPopupOptions {
+    Ark_Tag tag;
+    Ark_CustomPopupOptions value;
+} Opt_CustomPopupOptions;
 typedef struct Ark_DigitIndicator {
     /* kind: Interface */
     Opt_Length _left;
@@ -19075,6 +19377,37 @@ typedef struct Opt_LongPressGestureEvent {
     Ark_Tag tag;
     Ark_LongPressGestureEvent value;
 } Opt_LongPressGestureEvent;
+typedef struct Ark_MenuOptions {
+    /* kind: Interface */
+    Opt_Position offset;
+    Opt_Placement placement;
+    Opt_Boolean enableArrow;
+    Opt_Length arrowOffset;
+    Opt_Union_MenuPreviewMode_CustomBuilder preview;
+    Opt_BorderRadiusType previewBorderRadius;
+    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius;
+    Opt_Callback_Void onAppear;
+    Opt_Callback_Void onDisappear;
+    Opt_Callback_Void aboutToAppear;
+    Opt_Callback_Void aboutToDisappear;
+    Opt_Padding layoutRegionMargin;
+    Opt_ContextMenuAnimationOptions previewAnimationOptions;
+    Opt_ResourceColor backgroundColor;
+    Opt_BlurStyle backgroundBlurStyle;
+    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions;
+    Opt_BackgroundEffectOptions backgroundEffect;
+    Opt_TransitionEffect transition;
+    Opt_Boolean enableHoverMode;
+    Opt_Union_ResourceColor_EdgeColors outlineColor;
+    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth;
+    Opt_HapticFeedbackMode hapticFeedbackMode;
+    Opt_ResourceStr title;
+    Opt_Boolean showInSubWindow;
+} Ark_MenuOptions;
+typedef struct Opt_MenuOptions {
+    Ark_Tag tag;
+    Ark_MenuOptions value;
+} Opt_MenuOptions;
 typedef struct Ark_MenuOutlineOptions {
     /* kind: Interface */
     Opt_Union_Dimension_EdgeOutlineWidths width;
@@ -19199,6 +19532,35 @@ typedef struct Opt_PlaceholderStyle {
     Ark_Tag tag;
     Ark_PlaceholderStyle value;
 } Opt_PlaceholderStyle;
+typedef struct Ark_PopupCommonOptions {
+    /* kind: Interface */
+    Opt_Placement placement;
+    Opt_ResourceColor popupColor;
+    Opt_Boolean enableArrow;
+    Opt_Boolean autoCancel;
+    Opt_PopupStateChangeCallback onStateChange;
+    Opt_Length arrowOffset;
+    Opt_Boolean showInSubWindow;
+    Opt_Union_Boolean_PopupMaskType mask;
+    Opt_Length targetSpace;
+    Opt_Position offset;
+    Opt_Dimension width;
+    Opt_ArrowPointPosition arrowPointPosition;
+    Opt_Dimension arrowWidth;
+    Opt_Dimension arrowHeight;
+    Opt_Dimension radius;
+    Opt_Union_ShadowOptions_ShadowStyle shadow;
+    Opt_BlurStyle backgroundBlurStyle;
+    Opt_Boolean focusable;
+    Opt_TransitionEffect transition;
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
+    Opt_Boolean enableHoverMode;
+    Opt_Boolean followTransformOfTarget;
+} Ark_PopupCommonOptions;
+typedef struct Opt_PopupCommonOptions {
+    Ark_Tag tag;
+    Ark_PopupCommonOptions value;
+} Opt_PopupCommonOptions;
 typedef struct Ark_PopupMessageOptions {
     /* kind: Interface */
     Opt_ResourceColor textColor;
@@ -19577,6 +19939,39 @@ typedef struct Opt_NativeEmbedTouchInfo {
     Ark_Tag tag;
     Ark_NativeEmbedTouchInfo value;
 } Opt_NativeEmbedTouchInfo;
+typedef struct Ark_PopupOptions {
+    /* kind: Interface */
+    Ark_String message;
+    Opt_Placement placement;
+    Opt_PopupButton primaryButton;
+    Opt_PopupButton secondaryButton;
+    Opt_PopupStateChangeCallback onStateChange;
+    Opt_Length arrowOffset;
+    Opt_Boolean showInSubWindow;
+    Opt_Union_Boolean_PopupMaskType mask;
+    Opt_PopupMessageOptions messageOptions;
+    Opt_Length targetSpace;
+    Opt_Boolean enableArrow;
+    Opt_Position offset;
+    Opt_Union_Color_String_Resource_Number popupColor;
+    Opt_Boolean autoCancel;
+    Opt_Dimension width;
+    Opt_ArrowPointPosition arrowPointPosition;
+    Opt_Dimension arrowWidth;
+    Opt_Dimension arrowHeight;
+    Opt_Dimension radius;
+    Opt_Union_ShadowOptions_ShadowStyle shadow;
+    Opt_BlurStyle backgroundBlurStyle;
+    Opt_TransitionEffect transition;
+    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
+    Opt_Boolean enableHoverMode;
+    Opt_Boolean followTransformOfTarget;
+    Opt_KeyboardAvoidMode keyboardAvoidMode;
+} Ark_PopupOptions;
+typedef struct Opt_PopupOptions {
+    Ark_Tag tag;
+    Ark_PopupOptions value;
+} Opt_PopupOptions;
 typedef struct Ark_ResourceImageAttachmentOptions {
     /* kind: Interface */
     Opt_ResourceStr resourceValue;
@@ -19786,6 +20181,18 @@ typedef struct Opt_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_Strin
     Ark_Tag tag;
     Ark_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions value;
 } Opt_Union_ComponentContent_SubTabBarStyle_BottomTabBarStyle_String_Resource_CustomBuilder_TabBarOptions;
+typedef struct Ark_Union_PopupOptions_CustomPopupOptions {
+    /* kind: UnionType */
+    Ark_Int32 selector;
+    union {
+        Ark_PopupOptions value0;
+        Ark_CustomPopupOptions value1;
+    };
+} Ark_Union_PopupOptions_CustomPopupOptions;
+typedef struct Opt_Union_PopupOptions_CustomPopupOptions {
+    Ark_Tag tag;
+    Ark_Union_PopupOptions_CustomPopupOptions value;
+} Opt_Union_PopupOptions_CustomPopupOptions;
 typedef struct Ark_Union_RichEditorUpdateTextSpanStyleOptions_RichEditorUpdateImageSpanStyleOptions_RichEditorUpdateSymbolSpanStyleOptions {
     /* kind: UnionType */
     Ark_Int32 selector;
@@ -19934,209 +20341,6 @@ typedef struct Opt_Union_ImageAttachmentInterface_Opt_AttachmentType {
     Ark_Tag tag;
     Ark_Union_ImageAttachmentInterface_Opt_AttachmentType value;
 } Opt_Union_ImageAttachmentInterface_Opt_AttachmentType;
-typedef struct Ark_AsymmetricTransitionOption {
-    /* kind: Interface */
-    Ark_TransitionEffect appear;
-    Ark_TransitionEffect disappear;
-} Ark_AsymmetricTransitionOption;
-typedef struct Opt_AsymmetricTransitionOption {
-    Ark_Tag tag;
-    Ark_AsymmetricTransitionOption value;
-} Opt_AsymmetricTransitionOption;
-typedef struct Ark_ContentCoverOptions {
-    /* kind: Interface */
-    Opt_ResourceColor backgroundColor;
-    Opt_Callback_Void onAppear;
-    Opt_Callback_Void onDisappear;
-    Opt_Callback_Void onWillAppear;
-    Opt_Callback_Void onWillDisappear;
-    Opt_ModalTransition modalTransition;
-    Opt_Callback_DismissContentCoverAction_Void onWillDismiss;
-    Opt_TransitionEffect transition;
-} Ark_ContentCoverOptions;
-typedef struct Opt_ContentCoverOptions {
-    Ark_Tag tag;
-    Ark_ContentCoverOptions value;
-} Opt_ContentCoverOptions;
-typedef struct Ark_ContextMenuAnimationOptions {
-    /* kind: Interface */
-    Opt_AnimationNumberRange scale;
-    Opt_TransitionEffect transition;
-    Opt_AnimationNumberRange hoverScale;
-} Ark_ContextMenuAnimationOptions;
-typedef struct Opt_ContextMenuAnimationOptions {
-    Ark_Tag tag;
-    Ark_ContextMenuAnimationOptions value;
-} Opt_ContextMenuAnimationOptions;
-typedef struct Ark_ContextMenuOptions {
-    /* kind: Interface */
-    Opt_Position offset;
-    Opt_Placement placement;
-    Opt_Boolean enableArrow;
-    Opt_Length arrowOffset;
-    Opt_Union_MenuPreviewMode_CustomBuilder preview;
-    Opt_BorderRadiusType previewBorderRadius;
-    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius;
-    Opt_Callback_Void onAppear;
-    Opt_Callback_Void onDisappear;
-    Opt_Callback_Void aboutToAppear;
-    Opt_Callback_Void aboutToDisappear;
-    Opt_Padding layoutRegionMargin;
-    Opt_ContextMenuAnimationOptions previewAnimationOptions;
-    Opt_ResourceColor backgroundColor;
-    Opt_BlurStyle backgroundBlurStyle;
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions;
-    Opt_BackgroundEffectOptions backgroundEffect;
-    Opt_TransitionEffect transition;
-    Opt_Boolean enableHoverMode;
-    Opt_Union_ResourceColor_EdgeColors outlineColor;
-    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth;
-    Opt_HapticFeedbackMode hapticFeedbackMode;
-} Ark_ContextMenuOptions;
-typedef struct Opt_ContextMenuOptions {
-    Ark_Tag tag;
-    Ark_ContextMenuOptions value;
-} Opt_ContextMenuOptions;
-typedef struct Ark_CustomPopupOptions {
-    /* kind: Interface */
-    CustomNodeBuilder builder;
-    Opt_Placement placement;
-    Opt_Union_Color_String_Resource_Number popupColor;
-    Opt_Boolean enableArrow;
-    Opt_Boolean autoCancel;
-    Opt_PopupStateChangeCallback onStateChange;
-    Opt_Length arrowOffset;
-    Opt_Boolean showInSubWindow;
-    Opt_Union_Boolean_PopupMaskType mask;
-    Opt_Length targetSpace;
-    Opt_Position offset;
-    Opt_Dimension width;
-    Opt_ArrowPointPosition arrowPointPosition;
-    Opt_Dimension arrowWidth;
-    Opt_Dimension arrowHeight;
-    Opt_Dimension radius;
-    Opt_Union_ShadowOptions_ShadowStyle shadow;
-    Opt_BlurStyle backgroundBlurStyle;
-    Opt_Boolean focusable;
-    Opt_TransitionEffect transition;
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
-    Opt_Boolean enableHoverMode;
-    Opt_Boolean followTransformOfTarget;
-    Opt_KeyboardAvoidMode keyboardAvoidMode;
-} Ark_CustomPopupOptions;
-typedef struct Opt_CustomPopupOptions {
-    Ark_Tag tag;
-    Ark_CustomPopupOptions value;
-} Opt_CustomPopupOptions;
-typedef struct Ark_MenuOptions {
-    /* kind: Interface */
-    Opt_Position offset;
-    Opt_Placement placement;
-    Opt_Boolean enableArrow;
-    Opt_Length arrowOffset;
-    Opt_Union_MenuPreviewMode_CustomBuilder preview;
-    Opt_BorderRadiusType previewBorderRadius;
-    Opt_Union_Length_BorderRadiuses_LocalizedBorderRadiuses borderRadius;
-    Opt_Callback_Void onAppear;
-    Opt_Callback_Void onDisappear;
-    Opt_Callback_Void aboutToAppear;
-    Opt_Callback_Void aboutToDisappear;
-    Opt_Padding layoutRegionMargin;
-    Opt_ContextMenuAnimationOptions previewAnimationOptions;
-    Opt_ResourceColor backgroundColor;
-    Opt_BlurStyle backgroundBlurStyle;
-    Opt_BackgroundBlurStyleOptions backgroundBlurStyleOptions;
-    Opt_BackgroundEffectOptions backgroundEffect;
-    Opt_TransitionEffect transition;
-    Opt_Boolean enableHoverMode;
-    Opt_Union_ResourceColor_EdgeColors outlineColor;
-    Opt_Union_Dimension_EdgeOutlineWidths outlineWidth;
-    Opt_HapticFeedbackMode hapticFeedbackMode;
-    Opt_ResourceStr title;
-    Opt_Boolean showInSubWindow;
-} Ark_MenuOptions;
-typedef struct Opt_MenuOptions {
-    Ark_Tag tag;
-    Ark_MenuOptions value;
-} Opt_MenuOptions;
-typedef struct Ark_PopupCommonOptions {
-    /* kind: Interface */
-    Opt_Placement placement;
-    Opt_ResourceColor popupColor;
-    Opt_Boolean enableArrow;
-    Opt_Boolean autoCancel;
-    Opt_PopupStateChangeCallback onStateChange;
-    Opt_Length arrowOffset;
-    Opt_Boolean showInSubWindow;
-    Opt_Union_Boolean_PopupMaskType mask;
-    Opt_Length targetSpace;
-    Opt_Position offset;
-    Opt_Dimension width;
-    Opt_ArrowPointPosition arrowPointPosition;
-    Opt_Dimension arrowWidth;
-    Opt_Dimension arrowHeight;
-    Opt_Dimension radius;
-    Opt_Union_ShadowOptions_ShadowStyle shadow;
-    Opt_BlurStyle backgroundBlurStyle;
-    Opt_Boolean focusable;
-    Opt_TransitionEffect transition;
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
-    Opt_Boolean enableHoverMode;
-    Opt_Boolean followTransformOfTarget;
-} Ark_PopupCommonOptions;
-typedef struct Opt_PopupCommonOptions {
-    Ark_Tag tag;
-    Ark_PopupCommonOptions value;
-} Opt_PopupCommonOptions;
-typedef struct Ark_PopupOptions {
-    /* kind: Interface */
-    Ark_String message;
-    Opt_Placement placement;
-    Opt_PopupButton primaryButton;
-    Opt_PopupButton secondaryButton;
-    Opt_PopupStateChangeCallback onStateChange;
-    Opt_Length arrowOffset;
-    Opt_Boolean showInSubWindow;
-    Opt_Union_Boolean_PopupMaskType mask;
-    Opt_PopupMessageOptions messageOptions;
-    Opt_Length targetSpace;
-    Opt_Boolean enableArrow;
-    Opt_Position offset;
-    Opt_Union_Color_String_Resource_Number popupColor;
-    Opt_Boolean autoCancel;
-    Opt_Dimension width;
-    Opt_ArrowPointPosition arrowPointPosition;
-    Opt_Dimension arrowWidth;
-    Opt_Dimension arrowHeight;
-    Opt_Dimension radius;
-    Opt_Union_ShadowOptions_ShadowStyle shadow;
-    Opt_BlurStyle backgroundBlurStyle;
-    Opt_TransitionEffect transition;
-    Opt_Union_Boolean_Callback_DismissPopupAction_Void onWillDismiss;
-    Opt_Boolean enableHoverMode;
-    Opt_Boolean followTransformOfTarget;
-    Opt_KeyboardAvoidMode keyboardAvoidMode;
-} Ark_PopupOptions;
-typedef struct Opt_PopupOptions {
-    Ark_Tag tag;
-    Ark_PopupOptions value;
-} Opt_PopupOptions;
-typedef struct Opt_TransitionEffect {
-    Ark_Tag tag;
-    Ark_TransitionEffect value;
-} Opt_TransitionEffect;
-typedef struct Ark_Union_PopupOptions_CustomPopupOptions {
-    /* kind: UnionType */
-    Ark_Int32 selector;
-    union {
-        Ark_PopupOptions value0;
-        Ark_CustomPopupOptions value1;
-    };
-} Ark_Union_PopupOptions_CustomPopupOptions;
-typedef struct Opt_Union_PopupOptions_CustomPopupOptions {
-    Ark_Tag tag;
-    Ark_Union_PopupOptions_CustomPopupOptions value;
-} Opt_Union_PopupOptions_CustomPopupOptions;
 
 
 
@@ -20303,6 +20507,39 @@ typedef struct GENERATED_ArkUIButtonModifier {
                             const Opt_Union_Number_Resource* value);
 } GENERATED_ArkUIButtonModifier;
 
+typedef struct GENERATED_ArkUICalendarModifier {
+    Ark_NativePointer (*construct)(Ark_Int32 id,
+                                   Ark_Int32 flags);
+    void (*setCalendarOptions)(Ark_NativePointer node,
+                               const Ark_CalendarRequestedMonths* value);
+    void (*setShowLunar)(Ark_NativePointer node,
+                         const Opt_Boolean* value);
+    void (*setShowHoliday)(Ark_NativePointer node,
+                           const Opt_Boolean* value);
+    void (*setNeedSlide)(Ark_NativePointer node,
+                         const Opt_Boolean* value);
+    void (*setStartOfWeek)(Ark_NativePointer node,
+                           const Opt_Number* value);
+    void (*setOffDays)(Ark_NativePointer node,
+                       const Opt_Number* value);
+    void (*setDirection)(Ark_NativePointer node,
+                         const Opt_Axis* value);
+    void (*setCurrentDayStyle)(Ark_NativePointer node,
+                               const Opt_CurrentDayStyle* value);
+    void (*setNonCurrentDayStyle)(Ark_NativePointer node,
+                                  const Opt_NonCurrentDayStyle* value);
+    void (*setTodayStyle)(Ark_NativePointer node,
+                          const Opt_TodayStyle* value);
+    void (*setWeekStyle)(Ark_NativePointer node,
+                         const Opt_WeekStyle* value);
+    void (*setWorkStateStyle)(Ark_NativePointer node,
+                              const Opt_WorkStateStyle* value);
+    void (*setOnSelectChange)(Ark_NativePointer node,
+                              const Opt_Callback_CalendarSelectedDate_Void* value);
+    void (*setOnRequestData)(Ark_NativePointer node,
+                             const Opt_Callback_CalendarRequestedData_Void* value);
+} GENERATED_ArkUICalendarModifier;
+
 typedef struct GENERATED_ArkUICalendarPickerModifier {
     Ark_NativePointer (*construct)(Ark_Int32 id,
                                    Ark_Int32 flags);
@@ -23696,16 +23933,6 @@ typedef struct GENERATED_ArkUIBaseContextAccessor {
     Ark_NativePointer (*getFinalizer)();
 } GENERATED_ArkUIBaseContextAccessor;
 
-typedef struct GENERATED_ArkUIBaseCustomDialogAccessor {
-    void (*destroyPeer)(Ark_BaseCustomDialog peer);
-    Ark_BaseCustomDialog (*construct)(const Opt_Boolean* useSharedStorage,
-                                      const Opt_CustomObject* storage);
-    Ark_NativePointer (*getFinalizer)();
-    Ark_CustomObject (*$_instantiate)(const Callback_T* factory,
-                                      const Opt_CustomObject* initializers,
-                                      const Opt_Callback_Void* content);
-} GENERATED_ArkUIBaseCustomDialogAccessor;
-
 typedef struct GENERATED_ArkUIBaseEventAccessor {
     void (*destroyPeer)(Ark_BaseEvent peer);
     Ark_BaseEvent (*construct)();
@@ -23809,6 +24036,15 @@ typedef struct GENERATED_ArkUIBuilderNodeOpsAccessor {
                                                        Ark_NativePointer node);
 } GENERATED_ArkUIBuilderNodeOpsAccessor;
 
+typedef struct GENERATED_ArkUICalendarControllerAccessor {
+    void (*destroyPeer)(Ark_CalendarController peer);
+    Ark_CalendarController (*construct)();
+    Ark_NativePointer (*getFinalizer)();
+    void (*backToToday)(Ark_CalendarController peer);
+    void (*goTo)(Ark_CalendarController peer,
+                 const Ark_CalendarSelectedDate* date);
+} GENERATED_ArkUICalendarControllerAccessor;
+
 typedef struct GENERATED_ArkUICalendarPickerDialogAccessor {
     void (*destroyPeer)(Ark_CalendarPickerDialog peer);
     Ark_CalendarPickerDialog (*construct)();
@@ -27601,18 +27837,14 @@ typedef struct GENERATED_ArkUITransitionEffectAccessor {
                                       const Ark_AnimateParam* value);
     Ark_TransitionEffect (*combine)(Ark_TransitionEffect peer,
                                     Ark_TransitionEffect transitionEffect);
-    Ark_TransitionEffect (*getIDENTITY)(Ark_TransitionEffect peer);
-    void (*setIDENTITY)(Ark_TransitionEffect peer,
-                        Ark_TransitionEffect IDENTITY);
-    Ark_TransitionEffect (*getOPACITY)(Ark_TransitionEffect peer);
-    void (*setOPACITY)(Ark_TransitionEffect peer,
-                       Ark_TransitionEffect OPACITY);
-    Ark_TransitionEffect (*getSLIDE)(Ark_TransitionEffect peer);
-    void (*setSLIDE)(Ark_TransitionEffect peer,
-                     Ark_TransitionEffect SLIDE);
-    Ark_TransitionEffect (*getSLIDE_SWITCH)(Ark_TransitionEffect peer);
-    void (*setSLIDE_SWITCH)(Ark_TransitionEffect peer,
-                            Ark_TransitionEffect SLIDE_SWITCH);
+    Ark_TransitionEffect (*getIDENTITY)();
+    void (*setIDENTITY)(Ark_TransitionEffect IDENTITY);
+    Ark_TransitionEffect (*getOPACITY)();
+    void (*setOPACITY)(Ark_TransitionEffect OPACITY);
+    Ark_TransitionEffect (*getSLIDE)();
+    void (*setSLIDE)(Ark_TransitionEffect SLIDE);
+    Ark_TransitionEffect (*getSLIDE_SWITCH)();
+    void (*setSLIDE_SWITCH)(Ark_TransitionEffect SLIDE_SWITCH);
 } GENERATED_ArkUITransitionEffectAccessor;
 
 typedef struct GENERATED_ArkUIUICommonEventAccessor {
@@ -28013,6 +28245,7 @@ typedef struct GENERATED_ArkUINodeModifiers {
     const GENERATED_ArkUIBaseSpanModifier* (*getBaseSpanModifier)();
     const GENERATED_ArkUIBlankModifier* (*getBlankModifier)();
     const GENERATED_ArkUIButtonModifier* (*getButtonModifier)();
+    const GENERATED_ArkUICalendarModifier* (*getCalendarModifier)();
     const GENERATED_ArkUICalendarPickerModifier* (*getCalendarPickerModifier)();
     const GENERATED_ArkUICanvasModifier* (*getCanvasModifier)();
     const GENERATED_ArkUICheckboxModifier* (*getCheckboxModifier)();
@@ -28121,13 +28354,13 @@ typedef struct GENERATED_ArkUIAccessors {
     const GENERATED_ArkUIAxisEventAccessor* (*getAxisEventAccessor)();
     const GENERATED_ArkUIBackgroundColorStyleAccessor* (*getBackgroundColorStyleAccessor)();
     const GENERATED_ArkUIBaseContextAccessor* (*getBaseContextAccessor)();
-    const GENERATED_ArkUIBaseCustomDialogAccessor* (*getBaseCustomDialogAccessor)();
     const GENERATED_ArkUIBaseEventAccessor* (*getBaseEventAccessor)();
     const GENERATED_ArkUIBaseGestureEventAccessor* (*getBaseGestureEventAccessor)();
     const GENERATED_ArkUIBaselineOffsetStyleAccessor* (*getBaselineOffsetStyleAccessor)();
     const GENERATED_ArkUIBaseShapeAccessor* (*getBaseShapeAccessor)();
     const GENERATED_ArkUIBounceSymbolEffectAccessor* (*getBounceSymbolEffectAccessor)();
     const GENERATED_ArkUIBuilderNodeOpsAccessor* (*getBuilderNodeOpsAccessor)();
+    const GENERATED_ArkUICalendarControllerAccessor* (*getCalendarControllerAccessor)();
     const GENERATED_ArkUICalendarPickerDialogAccessor* (*getCalendarPickerDialogAccessor)();
     const GENERATED_ArkUICanvasGradientAccessor* (*getCanvasGradientAccessor)();
     const GENERATED_ArkUICanvasPathAccessor* (*getCanvasPathAccessor)();
@@ -28362,6 +28595,7 @@ typedef enum GENERATED_Ark_NodeType {
     GENERATED_ARKUI_BASE_SPAN,
     GENERATED_ARKUI_BLANK,
     GENERATED_ARKUI_BUTTON,
+    GENERATED_ARKUI_CALENDAR,
     GENERATED_ARKUI_CALENDAR_PICKER,
     GENERATED_ARKUI_CANVAS,
     GENERATED_ARKUI_CHECKBOX,
diff --git a/arkoala-arkts/framework/native/src/generated/bridge_generated.cc b/arkoala-arkts/framework/native/src/generated/bridge_generated.cc
index cbb4333a33..befa467b10 100644
--- a/arkoala-arkts/framework/native/src/generated/bridge_generated.cc
+++ b/arkoala-arkts/framework/native/src/generated/bridge_generated.cc
@@ -1307,6 +1307,199 @@ void impl_ButtonAttribute_setMaxFontScale(Ark_NativePointer thisPtr, KSerializer
         GetNodeModifiers()->getButtonModifier()->setMaxFontScale(self, static_cast<Opt_Union_Number_Resource*>(&value_value));
 }
 KOALA_INTEROP_DIRECT_V3(ButtonAttribute_setMaxFontScale, Ark_NativePointer, KSerializerBuffer, int32_t)
+Ark_NativePointer impl_Calendar_construct(Ark_Int32 id, Ark_Int32 flags) {
+        return GetNodeModifiers()->getCalendarModifier()->construct(id, flags);
+}
+KOALA_INTEROP_DIRECT_2(Calendar_construct, Ark_NativePointer, Ark_Int32, Ark_Int32)
+void impl_CalendarInterface_setCalendarOptions(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        Ark_CalendarRequestedMonths value_value = CalendarRequestedMonths_serializer::read(thisDeserializer);;
+        GetNodeModifiers()->getCalendarModifier()->setCalendarOptions(self, static_cast<Ark_CalendarRequestedMonths*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarInterface_setCalendarOptions, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setShowLunar(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Boolean value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = thisDeserializer.readBoolean();
+        }
+        Opt_Boolean value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setShowLunar(self, static_cast<Opt_Boolean*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setShowLunar, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setShowHoliday(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Boolean value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = thisDeserializer.readBoolean();
+        }
+        Opt_Boolean value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setShowHoliday(self, static_cast<Opt_Boolean*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setShowHoliday, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setNeedSlide(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Boolean value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = thisDeserializer.readBoolean();
+        }
+        Opt_Boolean value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setNeedSlide(self, static_cast<Opt_Boolean*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setNeedSlide, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setStartOfWeek(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Number value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = static_cast<Ark_Number>(thisDeserializer.readNumber());
+        }
+        Opt_Number value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setStartOfWeek(self, static_cast<Opt_Number*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setStartOfWeek, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setOffDays(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Number value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = static_cast<Ark_Number>(thisDeserializer.readNumber());
+        }
+        Opt_Number value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setOffDays(self, static_cast<Opt_Number*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setOffDays, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setDirection(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Axis value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = static_cast<Ark_Axis>(thisDeserializer.readInt32());
+        }
+        Opt_Axis value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setDirection(self, static_cast<Opt_Axis*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setDirection, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setCurrentDayStyle(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_CurrentDayStyle value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = CurrentDayStyle_serializer::read(thisDeserializer);
+        }
+        Opt_CurrentDayStyle value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setCurrentDayStyle(self, static_cast<Opt_CurrentDayStyle*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setCurrentDayStyle, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setNonCurrentDayStyle(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_NonCurrentDayStyle value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = NonCurrentDayStyle_serializer::read(thisDeserializer);
+        }
+        Opt_NonCurrentDayStyle value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setNonCurrentDayStyle(self, static_cast<Opt_NonCurrentDayStyle*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setNonCurrentDayStyle, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setTodayStyle(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_TodayStyle value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = TodayStyle_serializer::read(thisDeserializer);
+        }
+        Opt_TodayStyle value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setTodayStyle(self, static_cast<Opt_TodayStyle*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setTodayStyle, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setWeekStyle(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_WeekStyle value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = WeekStyle_serializer::read(thisDeserializer);
+        }
+        Opt_WeekStyle value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setWeekStyle(self, static_cast<Opt_WeekStyle*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setWeekStyle, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setWorkStateStyle(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_WorkStateStyle value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = WorkStateStyle_serializer::read(thisDeserializer);
+        }
+        Opt_WorkStateStyle value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setWorkStateStyle(self, static_cast<Opt_WorkStateStyle*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setWorkStateStyle, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setOnSelectChange(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Callback_CalendarSelectedDate_Void value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = {thisDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_CalendarSelectedDate_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_CalendarSelectedDate_Void))))};
+        }
+        Opt_Callback_CalendarSelectedDate_Void value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setOnSelectChange(self, static_cast<Opt_Callback_CalendarSelectedDate_Void*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setOnSelectChange, Ark_NativePointer, KSerializerBuffer, int32_t)
+void impl_CalendarAttribute_setOnRequestData(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_NodeHandle self = reinterpret_cast<Ark_NodeHandle>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        const auto value_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
+        Opt_Callback_CalendarRequestedData_Void value_value_buf = {};
+        value_value_buf.tag = value_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
+        if ((value_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
+        {
+            value_value_buf.value = {thisDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_CalendarRequestedData event)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_CalendarRequestedData_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarRequestedData event)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_CalendarRequestedData_Void))))};
+        }
+        Opt_Callback_CalendarRequestedData_Void value_value = value_value_buf;;
+        GetNodeModifiers()->getCalendarModifier()->setOnRequestData(self, static_cast<Opt_Callback_CalendarRequestedData_Void*>(&value_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarAttribute_setOnRequestData, Ark_NativePointer, KSerializerBuffer, int32_t)
 Ark_NativePointer impl_CalendarPicker_construct(Ark_Int32 id, Ark_Int32 flags) {
         return GetNodeModifiers()->getCalendarPickerModifier()->construct(id, flags);
 }
@@ -27401,53 +27594,6 @@ Ark_NativePointer impl_BaseContext_getFinalizer() {
         return GetAccessors()->getBaseContextAccessor()->getFinalizer();
 }
 KOALA_INTEROP_DIRECT_0(BaseContext_getFinalizer, Ark_NativePointer)
-Ark_NativePointer impl_BaseCustomDialog_construct(KSerializerBuffer thisArray, int32_t thisLength) {
-        DeserializerBase thisDeserializer(thisArray, thisLength);
-        const auto useSharedStorage_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
-        Opt_Boolean useSharedStorage_value_buf = {};
-        useSharedStorage_value_buf.tag = useSharedStorage_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((useSharedStorage_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            useSharedStorage_value_buf.value = thisDeserializer.readBoolean();
-        }
-        Opt_Boolean useSharedStorage_value = useSharedStorage_value_buf;;
-        const auto storage_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
-        Opt_CustomObject storage_value_buf = {};
-        storage_value_buf.tag = storage_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((storage_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            storage_value_buf.value = static_cast<Ark_CustomObject>(thisDeserializer.readCustomObject("object"));
-        }
-        Opt_CustomObject storage_value = storage_value_buf;;
-        return GetAccessors()->getBaseCustomDialogAccessor()->construct(static_cast<Opt_Boolean*>(&useSharedStorage_value), static_cast<Opt_CustomObject*>(&storage_value));
-}
-KOALA_INTEROP_DIRECT_2(BaseCustomDialog_construct, Ark_NativePointer, KSerializerBuffer, int32_t)
-Ark_NativePointer impl_BaseCustomDialog_getFinalizer() {
-        return GetAccessors()->getBaseCustomDialogAccessor()->getFinalizer();
-}
-KOALA_INTEROP_DIRECT_0(BaseCustomDialog_getFinalizer, Ark_NativePointer)
-void impl_BaseCustomDialog_$_instantiate(KSerializerBuffer thisArray, int32_t thisLength) {
-        DeserializerBase thisDeserializer(thisArray, thisLength);
-        Callback_T factory_value = {thisDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Callback_T_Void continuation)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_T)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Callback_T_Void continuation)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_T))))};;
-        const auto initializers_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
-        Opt_CustomObject initializers_value_buf = {};
-        initializers_value_buf.tag = initializers_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((initializers_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            initializers_value_buf.value = static_cast<Ark_CustomObject>(thisDeserializer.readCustomObject("T_Options"));
-        }
-        Opt_CustomObject initializers_value = initializers_value_buf;;
-        const auto content_value_buf_runtimeType = static_cast<Ark_RuntimeType>(thisDeserializer.readInt8());
-        Opt_Callback_Void content_value_buf = {};
-        content_value_buf.tag = content_value_buf_runtimeType == INTEROP_RUNTIME_UNDEFINED ? INTEROP_TAG_UNDEFINED : INTEROP_TAG_OBJECT;
-        if ((content_value_buf_runtimeType) != (INTEROP_RUNTIME_UNDEFINED))
-        {
-            content_value_buf.value = {thisDeserializer.readCallbackResource(), reinterpret_cast<void(*)(const Ark_Int32 resourceId)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCaller(Kind_Callback_Void)))), reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId)>(thisDeserializer.readPointerOrDefault(reinterpret_cast<Ark_NativePointer>(getManagedCallbackCallerSync(Kind_Callback_Void))))};
-        }
-        Opt_Callback_Void content_value = content_value_buf;;
-        GetAccessors()->getBaseCustomDialogAccessor()->$_instantiate(static_cast<Callback_T*>(&factory_value), static_cast<Opt_CustomObject*>(&initializers_value), static_cast<Opt_Callback_Void*>(&content_value));
-}
-KOALA_INTEROP_DIRECT_V2(BaseCustomDialog_$_instantiate, KSerializerBuffer, int32_t)
 Ark_NativePointer impl_BaseEvent_construct() {
         return GetAccessors()->getBaseEventAccessor()->construct();
 }
@@ -27938,6 +28084,26 @@ Ark_NativePointer impl_BuilderNodeOps_setRootFrameNodeInBuilderNode(Ark_NativePo
         return GetAccessors()->getBuilderNodeOpsAccessor()->setRootFrameNodeInBuilderNode(self, node);
 }
 KOALA_INTEROP_DIRECT_2(BuilderNodeOps_setRootFrameNodeInBuilderNode, Ark_NativePointer, Ark_NativePointer, Ark_NativePointer)
+Ark_NativePointer impl_CalendarController_construct() {
+        return GetAccessors()->getCalendarControllerAccessor()->construct();
+}
+KOALA_INTEROP_DIRECT_0(CalendarController_construct, Ark_NativePointer)
+Ark_NativePointer impl_CalendarController_getFinalizer() {
+        return GetAccessors()->getCalendarControllerAccessor()->getFinalizer();
+}
+KOALA_INTEROP_DIRECT_0(CalendarController_getFinalizer, Ark_NativePointer)
+void impl_CalendarController_backToToday(Ark_NativePointer thisPtr) {
+        Ark_CalendarController self = reinterpret_cast<Ark_CalendarController>(thisPtr);
+        GetAccessors()->getCalendarControllerAccessor()->backToToday(self);
+}
+KOALA_INTEROP_DIRECT_V1(CalendarController_backToToday, Ark_NativePointer)
+void impl_CalendarController_goTo(Ark_NativePointer thisPtr, KSerializerBuffer thisArray, int32_t thisLength) {
+        Ark_CalendarController self = reinterpret_cast<Ark_CalendarController>(thisPtr);
+        DeserializerBase thisDeserializer(thisArray, thisLength);
+        Ark_CalendarSelectedDate date_value = CalendarSelectedDate_serializer::read(thisDeserializer);;
+        GetAccessors()->getCalendarControllerAccessor()->goTo(self, static_cast<Ark_CalendarSelectedDate*>(&date_value));
+}
+KOALA_INTEROP_DIRECT_V3(CalendarController_goTo, Ark_NativePointer, KSerializerBuffer, int32_t)
 Ark_NativePointer impl_CalendarPickerDialog_construct() {
         return GetAccessors()->getCalendarPickerDialogAccessor()->construct();
 }
@@ -41123,46 +41289,38 @@ Ark_NativePointer impl_TransitionEffect_combine(Ark_NativePointer thisPtr, Ark_N
         return GetAccessors()->getTransitionEffectAccessor()->combine(self, static_cast<Ark_TransitionEffect>(transitionEffect));
 }
 KOALA_INTEROP_DIRECT_2(TransitionEffect_combine, Ark_NativePointer, Ark_NativePointer, Ark_NativePointer)
-Ark_NativePointer impl_TransitionEffect_getIDENTITY(Ark_NativePointer thisPtr) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        return GetAccessors()->getTransitionEffectAccessor()->getIDENTITY(self);
+Ark_NativePointer impl_TransitionEffect_getIDENTITY() {
+        return GetAccessors()->getTransitionEffectAccessor()->getIDENTITY();
 }
-KOALA_INTEROP_DIRECT_1(TransitionEffect_getIDENTITY, Ark_NativePointer, Ark_NativePointer)
-void impl_TransitionEffect_setIDENTITY(Ark_NativePointer thisPtr, Ark_NativePointer IDENTITY) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        GetAccessors()->getTransitionEffectAccessor()->setIDENTITY(self, static_cast<Ark_TransitionEffect>(IDENTITY));
+KOALA_INTEROP_DIRECT_0(TransitionEffect_getIDENTITY, Ark_NativePointer)
+void impl_TransitionEffect_setIDENTITY(Ark_NativePointer IDENTITY) {
+        GetAccessors()->getTransitionEffectAccessor()->setIDENTITY(static_cast<Ark_TransitionEffect>(IDENTITY));
 }
-KOALA_INTEROP_DIRECT_V2(TransitionEffect_setIDENTITY, Ark_NativePointer, Ark_NativePointer)
-Ark_NativePointer impl_TransitionEffect_getOPACITY(Ark_NativePointer thisPtr) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        return GetAccessors()->getTransitionEffectAccessor()->getOPACITY(self);
+KOALA_INTEROP_DIRECT_V1(TransitionEffect_setIDENTITY, Ark_NativePointer)
+Ark_NativePointer impl_TransitionEffect_getOPACITY() {
+        return GetAccessors()->getTransitionEffectAccessor()->getOPACITY();
 }
-KOALA_INTEROP_DIRECT_1(TransitionEffect_getOPACITY, Ark_NativePointer, Ark_NativePointer)
-void impl_TransitionEffect_setOPACITY(Ark_NativePointer thisPtr, Ark_NativePointer OPACITY) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        GetAccessors()->getTransitionEffectAccessor()->setOPACITY(self, static_cast<Ark_TransitionEffect>(OPACITY));
+KOALA_INTEROP_DIRECT_0(TransitionEffect_getOPACITY, Ark_NativePointer)
+void impl_TransitionEffect_setOPACITY(Ark_NativePointer OPACITY) {
+        GetAccessors()->getTransitionEffectAccessor()->setOPACITY(static_cast<Ark_TransitionEffect>(OPACITY));
 }
-KOALA_INTEROP_DIRECT_V2(TransitionEffect_setOPACITY, Ark_NativePointer, Ark_NativePointer)
-Ark_NativePointer impl_TransitionEffect_getSLIDE(Ark_NativePointer thisPtr) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        return GetAccessors()->getTransitionEffectAccessor()->getSLIDE(self);
+KOALA_INTEROP_DIRECT_V1(TransitionEffect_setOPACITY, Ark_NativePointer)
+Ark_NativePointer impl_TransitionEffect_getSLIDE() {
+        return GetAccessors()->getTransitionEffectAccessor()->getSLIDE();
 }
-KOALA_INTEROP_DIRECT_1(TransitionEffect_getSLIDE, Ark_NativePointer, Ark_NativePointer)
-void impl_TransitionEffect_setSLIDE(Ark_NativePointer thisPtr, Ark_NativePointer SLIDE) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        GetAccessors()->getTransitionEffectAccessor()->setSLIDE(self, static_cast<Ark_TransitionEffect>(SLIDE));
+KOALA_INTEROP_DIRECT_0(TransitionEffect_getSLIDE, Ark_NativePointer)
+void impl_TransitionEffect_setSLIDE(Ark_NativePointer SLIDE) {
+        GetAccessors()->getTransitionEffectAccessor()->setSLIDE(static_cast<Ark_TransitionEffect>(SLIDE));
 }
-KOALA_INTEROP_DIRECT_V2(TransitionEffect_setSLIDE, Ark_NativePointer, Ark_NativePointer)
-Ark_NativePointer impl_TransitionEffect_getSLIDE_SWITCH(Ark_NativePointer thisPtr) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        return GetAccessors()->getTransitionEffectAccessor()->getSLIDE_SWITCH(self);
+KOALA_INTEROP_DIRECT_V1(TransitionEffect_setSLIDE, Ark_NativePointer)
+Ark_NativePointer impl_TransitionEffect_getSLIDE_SWITCH() {
+        return GetAccessors()->getTransitionEffectAccessor()->getSLIDE_SWITCH();
 }
-KOALA_INTEROP_DIRECT_1(TransitionEffect_getSLIDE_SWITCH, Ark_NativePointer, Ark_NativePointer)
-void impl_TransitionEffect_setSLIDE_SWITCH(Ark_NativePointer thisPtr, Ark_NativePointer SLIDE_SWITCH) {
-        Ark_TransitionEffect self = reinterpret_cast<Ark_TransitionEffect>(thisPtr);
-        GetAccessors()->getTransitionEffectAccessor()->setSLIDE_SWITCH(self, static_cast<Ark_TransitionEffect>(SLIDE_SWITCH));
+KOALA_INTEROP_DIRECT_0(TransitionEffect_getSLIDE_SWITCH, Ark_NativePointer)
+void impl_TransitionEffect_setSLIDE_SWITCH(Ark_NativePointer SLIDE_SWITCH) {
+        GetAccessors()->getTransitionEffectAccessor()->setSLIDE_SWITCH(static_cast<Ark_TransitionEffect>(SLIDE_SWITCH));
 }
-KOALA_INTEROP_DIRECT_V2(TransitionEffect_setSLIDE_SWITCH, Ark_NativePointer, Ark_NativePointer)
+KOALA_INTEROP_DIRECT_V1(TransitionEffect_setSLIDE_SWITCH, Ark_NativePointer)
 Ark_NativePointer impl_UICommonEvent_construct() {
         return GetAccessors()->getUICommonEventAccessor()->construct();
 }
diff --git a/arkoala-arkts/framework/native/src/generated/callback_deserialize_call.cc b/arkoala-arkts/framework/native/src/generated/callback_deserialize_call.cc
index 76e53246b9..aa8f883a1c 100644
--- a/arkoala-arkts/framework/native/src/generated/callback_deserialize_call.cc
+++ b/arkoala-arkts/framework/native/src/generated/callback_deserialize_call.cc
@@ -360,6 +360,42 @@ void deserializeAndCallSyncCallback_Buffer_Void(Ark_VMContext vmContext, KSerial
     Ark_Buffer value = static_cast<Ark_Buffer>(thisDeserializer.readBuffer());
     _callSync(vmContext, _resourceId, value);
 }
+void deserializeAndCallCallback_CalendarRequestedData_Void(KSerializerBuffer thisArray, Ark_Int32 thisLength)
+{
+    DeserializerBase thisDeserializer = DeserializerBase(thisArray, thisLength);
+    const Ark_Int32 _resourceId = thisDeserializer.readInt32();
+    const auto _call = reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_CalendarRequestedData event)>(thisDeserializer.readPointer());
+    thisDeserializer.readPointer();
+    Ark_CalendarRequestedData event = CalendarRequestedData_serializer::read(thisDeserializer);
+    _call(_resourceId, event);
+}
+void deserializeAndCallSyncCallback_CalendarRequestedData_Void(Ark_VMContext vmContext, KSerializerBuffer thisArray, Ark_Int32 thisLength)
+{
+    DeserializerBase thisDeserializer = DeserializerBase(thisArray, thisLength);
+    const Ark_Int32 _resourceId = thisDeserializer.readInt32();
+    thisDeserializer.readPointer();
+    const auto _callSync = reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarRequestedData event)>(thisDeserializer.readPointer());
+    Ark_CalendarRequestedData event = CalendarRequestedData_serializer::read(thisDeserializer);
+    _callSync(vmContext, _resourceId, event);
+}
+void deserializeAndCallCallback_CalendarSelectedDate_Void(KSerializerBuffer thisArray, Ark_Int32 thisLength)
+{
+    DeserializerBase thisDeserializer = DeserializerBase(thisArray, thisLength);
+    const Ark_Int32 _resourceId = thisDeserializer.readInt32();
+    const auto _call = reinterpret_cast<void(*)(const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event)>(thisDeserializer.readPointer());
+    thisDeserializer.readPointer();
+    Ark_CalendarSelectedDate event = CalendarSelectedDate_serializer::read(thisDeserializer);
+    _call(_resourceId, event);
+}
+void deserializeAndCallSyncCallback_CalendarSelectedDate_Void(Ark_VMContext vmContext, KSerializerBuffer thisArray, Ark_Int32 thisLength)
+{
+    DeserializerBase thisDeserializer = DeserializerBase(thisArray, thisLength);
+    const Ark_Int32 _resourceId = thisDeserializer.readInt32();
+    thisDeserializer.readPointer();
+    const auto _callSync = reinterpret_cast<void(*)(Ark_VMContext vmContext, const Ark_Int32 resourceId, const Ark_CalendarSelectedDate event)>(thisDeserializer.readPointer());
+    Ark_CalendarSelectedDate event = CalendarSelectedDate_serializer::read(thisDeserializer);
+    _callSync(vmContext, _resourceId, event);
+}
 void deserializeAndCallCallback_ClickEvent_LocationButtonOnClickResult_Void(KSerializerBuffer thisArray, Ark_Int32 thisLength)
 {
     DeserializerBase thisDeserializer = DeserializerBase(thisArray, thisLength);
@@ -7222,6 +7258,8 @@ void deserializeAndCallCallback(Ark_Int32 kind, KSerializerBuffer thisArray, Ark
         case Kind_Callback_Boolean_HoverEvent_Void: return deserializeAndCallCallback_Boolean_HoverEvent_Void(thisArray, thisLength);
         case Kind_Callback_Boolean_Void: return deserializeAndCallCallback_Boolean_Void(thisArray, thisLength);
         case Kind_Callback_Buffer_Void: return deserializeAndCallCallback_Buffer_Void(thisArray, thisLength);
+        case Kind_Callback_CalendarRequestedData_Void: return deserializeAndCallCallback_CalendarRequestedData_Void(thisArray, thisLength);
+        case Kind_Callback_CalendarSelectedDate_Void: return deserializeAndCallCallback_CalendarSelectedDate_Void(thisArray, thisLength);
         case Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_LocationButtonOnClickResult_Void(thisArray, thisLength);
         case Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_PasteButtonOnClickResult_Void(thisArray, thisLength);
         case Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void: return deserializeAndCallCallback_ClickEvent_SaveButtonOnClickResult_Void(thisArray, thisLength);
@@ -7528,6 +7566,8 @@ void deserializeAndCallCallbackSync(Ark_VMContext vmContext, Ark_Int32 kind, KSe
         case Kind_Callback_Boolean_HoverEvent_Void: return deserializeAndCallSyncCallback_Boolean_HoverEvent_Void(vmContext, thisArray, thisLength);
         case Kind_Callback_Boolean_Void: return deserializeAndCallSyncCallback_Boolean_Void(vmContext, thisArray, thisLength);
         case Kind_Callback_Buffer_Void: return deserializeAndCallSyncCallback_Buffer_Void(vmContext, thisArray, thisLength);
+        case Kind_Callback_CalendarRequestedData_Void: return deserializeAndCallSyncCallback_CalendarRequestedData_Void(vmContext, thisArray, thisLength);
+        case Kind_Callback_CalendarSelectedDate_Void: return deserializeAndCallSyncCallback_CalendarSelectedDate_Void(vmContext, thisArray, thisLength);
         case Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void: return deserializeAndCallSyncCallback_ClickEvent_LocationButtonOnClickResult_Void(vmContext, thisArray, thisLength);
         case Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void: return deserializeAndCallSyncCallback_ClickEvent_PasteButtonOnClickResult_Void(vmContext, thisArray, thisLength);
         case Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void: return deserializeAndCallSyncCallback_ClickEvent_SaveButtonOnClickResult_Void(vmContext, thisArray, thisLength);
diff --git a/arkoala-arkts/framework/native/src/generated/callback_kind.h b/arkoala-arkts/framework/native/src/generated/callback_kind.h
index dde49d4a94..81608fa023 100644
--- a/arkoala-arkts/framework/native/src/generated/callback_kind.h
+++ b/arkoala-arkts/framework/native/src/generated/callback_kind.h
@@ -34,6 +34,8 @@ typedef enum CallbackKind {
     Kind_Callback_Boolean_HoverEvent_Void = -916602978,
     Kind_Callback_Boolean_Void = 313269291,
     Kind_Callback_Buffer_Void = 908731311,
+    Kind_Callback_CalendarRequestedData_Void = 1074619005,
+    Kind_Callback_CalendarSelectedDate_Void = -289198976,
     Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void = -1189087745,
     Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void = 659292561,
     Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void = 846787331,
diff --git a/arkoala-arkts/framework/native/src/generated/callback_managed_caller.cc b/arkoala-arkts/framework/native/src/generated/callback_managed_caller.cc
index b38caa269a..c133e4f494 100644
--- a/arkoala-arkts/framework/native/src/generated/callback_managed_caller.cc
+++ b/arkoala-arkts/framework/native/src/generated/callback_managed_caller.cc
@@ -378,6 +378,46 @@ void callManagedCallback_Buffer_VoidSync(Ark_VMContext vmContext, Ark_Int32 reso
     argsSerializer.writeBuffer(value);
     KOALA_INTEROP_CALL_VOID(vmContext, 1, sizeof(_buffer), _buffer);
 }
+void callManagedCallback_CalendarRequestedData_Void(Ark_Int32 resourceId, Ark_CalendarRequestedData event)
+{
+    CallbackBuffer _buffer = {{}, {}};
+    const Ark_CallbackResource _callbackResourceSelf = {resourceId, holdManagedCallbackResource, releaseManagedCallbackResource};
+    _buffer.resourceHolder.holdCallbackResource(&_callbackResourceSelf);
+    SerializerBase argsSerializer = SerializerBase((KSerializerBuffer)&(_buffer.buffer), sizeof(_buffer.buffer), &(_buffer.resourceHolder));
+    argsSerializer.writeInt32(Kind_Callback_CalendarRequestedData_Void);
+    argsSerializer.writeInt32(resourceId);
+    CalendarRequestedData_serializer::write(argsSerializer, event);
+    enqueueCallback(&_buffer);
+}
+void callManagedCallback_CalendarRequestedData_VoidSync(Ark_VMContext vmContext, Ark_Int32 resourceId, Ark_CalendarRequestedData event)
+{
+    uint8_t _buffer[4096];
+    SerializerBase argsSerializer = SerializerBase((KSerializerBuffer)&_buffer, sizeof(_buffer), nullptr);
+    argsSerializer.writeInt32(Kind_Callback_CalendarRequestedData_Void);
+    argsSerializer.writeInt32(resourceId);
+    CalendarRequestedData_serializer::write(argsSerializer, event);
+    KOALA_INTEROP_CALL_VOID(vmContext, 1, sizeof(_buffer), _buffer);
+}
+void callManagedCallback_CalendarSelectedDate_Void(Ark_Int32 resourceId, Ark_CalendarSelectedDate event)
+{
+    CallbackBuffer _buffer = {{}, {}};
+    const Ark_CallbackResource _callbackResourceSelf = {resourceId, holdManagedCallbackResource, releaseManagedCallbackResource};
+    _buffer.resourceHolder.holdCallbackResource(&_callbackResourceSelf);
+    SerializerBase argsSerializer = SerializerBase((KSerializerBuffer)&(_buffer.buffer), sizeof(_buffer.buffer), &(_buffer.resourceHolder));
+    argsSerializer.writeInt32(Kind_Callback_CalendarSelectedDate_Void);
+    argsSerializer.writeInt32(resourceId);
+    CalendarSelectedDate_serializer::write(argsSerializer, event);
+    enqueueCallback(&_buffer);
+}
+void callManagedCallback_CalendarSelectedDate_VoidSync(Ark_VMContext vmContext, Ark_Int32 resourceId, Ark_CalendarSelectedDate event)
+{
+    uint8_t _buffer[4096];
+    SerializerBase argsSerializer = SerializerBase((KSerializerBuffer)&_buffer, sizeof(_buffer), nullptr);
+    argsSerializer.writeInt32(Kind_Callback_CalendarSelectedDate_Void);
+    argsSerializer.writeInt32(resourceId);
+    CalendarSelectedDate_serializer::write(argsSerializer, event);
+    KOALA_INTEROP_CALL_VOID(vmContext, 1, sizeof(_buffer), _buffer);
+}
 void callManagedCallback_ClickEvent_LocationButtonOnClickResult_Void(Ark_Int32 resourceId, Ark_ClickEvent event, Ark_LocationButtonOnClickResult result)
 {
     CallbackBuffer _buffer = {{}, {}};
@@ -7756,6 +7796,8 @@ Ark_NativePointer getManagedCallbackCaller(CallbackKind kind)
         case Kind_Callback_Boolean_HoverEvent_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Boolean_HoverEvent_Void);
         case Kind_Callback_Boolean_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Boolean_Void);
         case Kind_Callback_Buffer_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Buffer_Void);
+        case Kind_Callback_CalendarRequestedData_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_CalendarRequestedData_Void);
+        case Kind_Callback_CalendarSelectedDate_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_CalendarSelectedDate_Void);
         case Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_LocationButtonOnClickResult_Void);
         case Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_PasteButtonOnClickResult_Void);
         case Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_SaveButtonOnClickResult_Void);
@@ -8061,6 +8103,8 @@ Ark_NativePointer getManagedCallbackCallerSync(CallbackKind kind)
         case Kind_Callback_Boolean_HoverEvent_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Boolean_HoverEvent_VoidSync);
         case Kind_Callback_Boolean_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Boolean_VoidSync);
         case Kind_Callback_Buffer_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_Buffer_VoidSync);
+        case Kind_Callback_CalendarRequestedData_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_CalendarRequestedData_VoidSync);
+        case Kind_Callback_CalendarSelectedDate_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_CalendarSelectedDate_VoidSync);
         case Kind_Callback_ClickEvent_LocationButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_LocationButtonOnClickResult_VoidSync);
         case Kind_Callback_ClickEvent_PasteButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_PasteButtonOnClickResult_VoidSync);
         case Kind_Callback_ClickEvent_SaveButtonOnClickResult_Void: return reinterpret_cast<Ark_NativePointer>(callManagedCallback_ClickEvent_SaveButtonOnClickResult_VoidSync);
diff --git a/arkoala-arkts/framework/native/src/generated/dummy_impl.cc b/arkoala-arkts/framework/native/src/generated/dummy_impl.cc
index e483d7ab79..36b38f18f0 100644
--- a/arkoala-arkts/framework/native/src/generated/dummy_impl.cc
+++ b/arkoala-arkts/framework/native/src/generated/dummy_impl.cc
@@ -1885,6 +1885,196 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
     }
     } // ButtonAttributeModifier
+    namespace CalendarModifier {
+    Ark_NativePointer ConstructImpl(Ark_Int32 id,
+                                    Ark_Int32 flags)
+    {
+        if (!needGroupedLog(1))
+        {
+            return new TreeNode("Calendar", id, flags);;
+        }
+        string out("construct(");
+        WriteToString(&out, id);
+        out.append(", ");
+        WriteToString(&out, flags);
+        out.append(") \n");
+        out.append("[return nullptr] \n");
+        appendGroupedLog(1, out);
+        return new TreeNode("Calendar", id, flags);;
+    }
+    } // CalendarModifier
+    namespace CalendarInterfaceModifier {
+    void SetCalendarOptionsImpl(Ark_NativePointer node,
+                                const Ark_CalendarRequestedMonths* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setCalendarOptions(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    } // CalendarInterfaceModifier
+    namespace CalendarAttributeModifier {
+    void ShowLunarImpl(Ark_NativePointer node,
+                       const Opt_Boolean* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setShowLunar(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void ShowHolidayImpl(Ark_NativePointer node,
+                         const Opt_Boolean* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setShowHoliday(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void NeedSlideImpl(Ark_NativePointer node,
+                       const Opt_Boolean* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setNeedSlide(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void StartOfWeekImpl(Ark_NativePointer node,
+                         const Opt_Number* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setStartOfWeek(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void OffDaysImpl(Ark_NativePointer node,
+                     const Opt_Number* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setOffDays(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void DirectionImpl(Ark_NativePointer node,
+                       const Opt_Axis* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setDirection(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void CurrentDayStyleImpl(Ark_NativePointer node,
+                             const Opt_CurrentDayStyle* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setCurrentDayStyle(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void NonCurrentDayStyleImpl(Ark_NativePointer node,
+                                const Opt_NonCurrentDayStyle* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setNonCurrentDayStyle(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void TodayStyleImpl(Ark_NativePointer node,
+                        const Opt_TodayStyle* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setTodayStyle(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void WeekStyleImpl(Ark_NativePointer node,
+                       const Opt_WeekStyle* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setWeekStyle(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void WorkStateStyleImpl(Ark_NativePointer node,
+                            const Opt_WorkStateStyle* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setWorkStateStyle(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void OnSelectChangeImpl(Ark_NativePointer node,
+                            const Opt_Callback_CalendarSelectedDate_Void* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setOnSelectChange(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void OnRequestDataImpl(Ark_NativePointer node,
+                           const Opt_Callback_CalendarRequestedData_Void* value)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("setOnRequestData(");
+        WriteToString(&out, value);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    } // CalendarAttributeModifier
     namespace CalendarPickerModifier {
     Ark_NativePointer ConstructImpl(Ark_Int32 id,
                                     Ark_Int32 flags)
@@ -2502,18 +2692,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    void DrawModifierImpl(Ark_NativePointer node,
-                          const Opt_DrawModifier* value)
-    {
-        if (!needGroupedLog(1))
-        {
-            return;
-        }
-        string out("setDrawModifier(");
-        WriteToString(&out, value);
-        out.append(") \n");
-        appendGroupedLog(1, out);
-    }
     void ResponseRegionImpl(Ark_NativePointer node,
                             const Opt_Union_Array_Rectangle_Rectangle* value)
     {
@@ -2934,18 +3112,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    void OnClick0Impl(Ark_NativePointer node,
-                      const Opt_Callback_ClickEvent_Void* value)
-    {
-        if (!needGroupedLog(1))
-        {
-            return;
-        }
-        string out("setOnClick0(");
-        WriteToString(&out, value);
-        out.append(") \n");
-        appendGroupedLog(1, out);
-    }
     void OnHoverImpl(Ark_NativePointer node,
                      const Opt_Callback_Boolean_HoverEvent_Void* value)
     {
@@ -4500,21 +4666,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    void OnClick1Impl(Ark_NativePointer node,
-                      const Opt_Callback_ClickEvent_Void* event,
-                      const Opt_Number* distanceThreshold)
-    {
-        if (!needGroupedLog(1))
-        {
-            return;
-        }
-        string out("setOnClick1(");
-        WriteToString(&out, event);
-        out.append(", ");
-        WriteToString(&out, distanceThreshold);
-        out.append(") \n");
-        appendGroupedLog(1, out);
-    }
     void FocusScopeIdImpl(Ark_NativePointer node,
                           const Opt_String* id,
                           const Opt_Boolean* isGroup,
@@ -20609,6 +20760,28 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return &ArkUIButtonModifierImpl;
     }
 
+    const GENERATED_ArkUICalendarModifier* GetCalendarModifier()
+    {
+        static const GENERATED_ArkUICalendarModifier ArkUICalendarModifierImpl {
+            CalendarModifier::ConstructImpl,
+            CalendarInterfaceModifier::SetCalendarOptionsImpl,
+            CalendarAttributeModifier::ShowLunarImpl,
+            CalendarAttributeModifier::ShowHolidayImpl,
+            CalendarAttributeModifier::NeedSlideImpl,
+            CalendarAttributeModifier::StartOfWeekImpl,
+            CalendarAttributeModifier::OffDaysImpl,
+            CalendarAttributeModifier::DirectionImpl,
+            CalendarAttributeModifier::CurrentDayStyleImpl,
+            CalendarAttributeModifier::NonCurrentDayStyleImpl,
+            CalendarAttributeModifier::TodayStyleImpl,
+            CalendarAttributeModifier::WeekStyleImpl,
+            CalendarAttributeModifier::WorkStateStyleImpl,
+            CalendarAttributeModifier::OnSelectChangeImpl,
+            CalendarAttributeModifier::OnRequestDataImpl,
+        };
+        return &ArkUICalendarModifierImpl;
+    }
+
     const GENERATED_ArkUICalendarPickerModifier* GetCalendarPickerModifier()
     {
         static const GENERATED_ArkUICalendarPickerModifier ArkUICalendarPickerModifierImpl {
@@ -22755,6 +22928,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
             GetBaseSpanModifier,
             GetBlankModifier,
             GetButtonModifier,
+            GetCalendarModifier,
             GetCalendarPickerModifier,
             GetCanvasModifier,
             GetCheckboxModifier,
@@ -23557,65 +23731,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return fnPtr<KNativePointer>(dummyClassFinalizer);
     }
     } // BaseContextAccessor
-    namespace BaseCustomDialogAccessor {
-    void DestroyPeerImpl(Ark_BaseCustomDialog peer)
-    {
-        if (!needGroupedLog(1))
-        {
-            return;
-        }
-        string out("destroyPeer(");
-        out.append(") \n");
-        appendGroupedLog(1, out);
-    }
-    Ark_BaseCustomDialog ConstructImpl(const Opt_Boolean* useSharedStorage,
-                                       const Opt_CustomObject* storage)
-    {
-        if (!needGroupedLog(1))
-        {
-            return reinterpret_cast<Ark_BaseCustomDialog>(100);
-        }
-        string out("new BaseCustomDialog(");
-        WriteToString(&out, useSharedStorage);
-        out.append(", ");
-        WriteToString(&out, storage);
-        out.append(") \n");
-        out.append("[return reinterpret_cast<Ark_BaseCustomDialog>(100)] \n");
-        appendGroupedLog(1, out);
-        return reinterpret_cast<Ark_BaseCustomDialog>(100);
-    }
-    Ark_NativePointer GetFinalizerImpl()
-    {
-        if (!needGroupedLog(1))
-        {
-            return fnPtr<KNativePointer>(dummyClassFinalizer);
-        }
-        string out("getFinalizer(");
-        out.append(") \n");
-        out.append("[return fnPtr<KNativePointer>(dummyClassFinalizer)] \n");
-        appendGroupedLog(1, out);
-        return fnPtr<KNativePointer>(dummyClassFinalizer);
-    }
-    Ark_CustomObject $_instantiateImpl(const Callback_T* factory,
-                                       const Opt_CustomObject* initializers,
-                                       const Opt_Callback_Void* content)
-    {
-        if (!needGroupedLog(1))
-        {
-            return {};
-        }
-        string out("$_instantiate(");
-        WriteToString(&out, factory);
-        out.append(", ");
-        WriteToString(&out, initializers);
-        out.append(", ");
-        WriteToString(&out, content);
-        out.append(") \n");
-        out.append("[return {}] \n");
-        appendGroupedLog(1, out);
-        return {};
-    }
-    } // BaseCustomDialogAccessor
     namespace BaseEventAccessor {
     void DestroyPeerImpl(Ark_BaseEvent peer)
     {
@@ -24349,6 +24464,64 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return nullptr;
     }
     } // BuilderNodeOpsAccessor
+    namespace CalendarControllerAccessor {
+    void DestroyPeerImpl(Ark_CalendarController peer)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("destroyPeer(");
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    Ark_CalendarController ConstructImpl()
+    {
+        if (!needGroupedLog(1))
+        {
+            return reinterpret_cast<Ark_CalendarController>(100);
+        }
+        string out("new CalendarController(");
+        out.append(") \n");
+        out.append("[return reinterpret_cast<Ark_CalendarController>(100)] \n");
+        appendGroupedLog(1, out);
+        return reinterpret_cast<Ark_CalendarController>(100);
+    }
+    Ark_NativePointer GetFinalizerImpl()
+    {
+        if (!needGroupedLog(1))
+        {
+            return fnPtr<KNativePointer>(dummyClassFinalizer);
+        }
+        string out("getFinalizer(");
+        out.append(") \n");
+        out.append("[return fnPtr<KNativePointer>(dummyClassFinalizer)] \n");
+        appendGroupedLog(1, out);
+        return fnPtr<KNativePointer>(dummyClassFinalizer);
+    }
+    void BackToTodayImpl(Ark_CalendarController peer)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("backToToday(");
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    void GoToImpl(Ark_CalendarController peer,
+                  const Ark_CalendarSelectedDate* date)
+    {
+        if (!needGroupedLog(1))
+        {
+            return;
+        }
+        string out("goTo(");
+        WriteToString(&out, date);
+        out.append(") \n");
+        appendGroupedLog(1, out);
+    }
+    } // CalendarControllerAccessor
     namespace CalendarPickerDialogAccessor {
     void DestroyPeerImpl(Ark_CalendarPickerDialog peer)
     {
@@ -48900,7 +49073,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
         return reinterpret_cast<Ark_TransitionEffect>(300);
     }
-    Ark_TransitionEffect GetIDENTITYImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetIDENTITYImpl()
     {
         if (!needGroupedLog(1))
         {
@@ -48912,8 +49085,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
         return reinterpret_cast<Ark_TransitionEffect>(300);
     }
-    void SetIDENTITYImpl(Ark_TransitionEffect peer,
-                         Ark_TransitionEffect IDENTITY)
+    void SetIDENTITYImpl(Ark_TransitionEffect IDENTITY)
     {
         if (!needGroupedLog(1))
         {
@@ -48924,7 +49096,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    Ark_TransitionEffect GetOPACITYImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetOPACITYImpl()
     {
         if (!needGroupedLog(1))
         {
@@ -48936,8 +49108,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
         return reinterpret_cast<Ark_TransitionEffect>(300);
     }
-    void SetOPACITYImpl(Ark_TransitionEffect peer,
-                        Ark_TransitionEffect OPACITY)
+    void SetOPACITYImpl(Ark_TransitionEffect OPACITY)
     {
         if (!needGroupedLog(1))
         {
@@ -48948,7 +49119,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    Ark_TransitionEffect GetSLIDEImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetSLIDEImpl()
     {
         if (!needGroupedLog(1))
         {
@@ -48960,8 +49131,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
         return reinterpret_cast<Ark_TransitionEffect>(300);
     }
-    void SetSLIDEImpl(Ark_TransitionEffect peer,
-                      Ark_TransitionEffect SLIDE)
+    void SetSLIDEImpl(Ark_TransitionEffect SLIDE)
     {
         if (!needGroupedLog(1))
         {
@@ -48972,7 +49142,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         out.append(") \n");
         appendGroupedLog(1, out);
     }
-    Ark_TransitionEffect GetSLIDE_SWITCHImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetSLIDE_SWITCHImpl()
     {
         if (!needGroupedLog(1))
         {
@@ -48984,8 +49154,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         appendGroupedLog(1, out);
         return reinterpret_cast<Ark_TransitionEffect>(300);
     }
-    void SetSLIDE_SWITCHImpl(Ark_TransitionEffect peer,
-                             Ark_TransitionEffect SLIDE_SWITCH)
+    void SetSLIDE_SWITCHImpl(Ark_TransitionEffect SLIDE_SWITCH)
     {
         if (!needGroupedLog(1))
         {
@@ -51767,20 +51936,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     struct BaseContextPeer {
         virtual ~BaseContextPeer() = default;
     };
-    const GENERATED_ArkUIBaseCustomDialogAccessor* GetBaseCustomDialogAccessor()
-    {
-        static const GENERATED_ArkUIBaseCustomDialogAccessor BaseCustomDialogAccessorImpl {
-            BaseCustomDialogAccessor::DestroyPeerImpl,
-            BaseCustomDialogAccessor::ConstructImpl,
-            BaseCustomDialogAccessor::GetFinalizerImpl,
-            BaseCustomDialogAccessor::$_instantiateImpl,
-        };
-        return &BaseCustomDialogAccessorImpl;
-    }
-
-    struct BaseCustomDialogPeer {
-        virtual ~BaseCustomDialogPeer() = default;
-    };
     const GENERATED_ArkUIBaseEventAccessor* GetBaseEventAccessor()
     {
         static const GENERATED_ArkUIBaseEventAccessor BaseEventAccessorImpl {
@@ -51901,6 +52056,21 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     struct BuilderNodeOpsPeer {
         virtual ~BuilderNodeOpsPeer() = default;
     };
+    const GENERATED_ArkUICalendarControllerAccessor* GetCalendarControllerAccessor()
+    {
+        static const GENERATED_ArkUICalendarControllerAccessor CalendarControllerAccessorImpl {
+            CalendarControllerAccessor::DestroyPeerImpl,
+            CalendarControllerAccessor::ConstructImpl,
+            CalendarControllerAccessor::GetFinalizerImpl,
+            CalendarControllerAccessor::BackToTodayImpl,
+            CalendarControllerAccessor::GoToImpl,
+        };
+        return &CalendarControllerAccessorImpl;
+    }
+
+    struct CalendarControllerPeer {
+        virtual ~CalendarControllerPeer() = default;
+    };
     const GENERATED_ArkUICalendarPickerDialogAccessor* GetCalendarPickerDialogAccessor()
     {
         static const GENERATED_ArkUICalendarPickerDialogAccessor CalendarPickerDialogAccessorImpl {
@@ -56158,13 +56328,13 @@ namespace OHOS::Ace::NG::GeneratedModifier {
             GetAxisEventAccessor,
             GetBackgroundColorStyleAccessor,
             GetBaseContextAccessor,
-            GetBaseCustomDialogAccessor,
             GetBaseEventAccessor,
             GetBaseGestureEventAccessor,
             GetBaselineOffsetStyleAccessor,
             GetBaseShapeAccessor,
             GetBounceSymbolEffectAccessor,
             GetBuilderNodeOpsAccessor,
+            GetCalendarControllerAccessor,
             GetCalendarPickerDialogAccessor,
             GetCanvasGradientAccessor,
             GetCanvasPathAccessor,
diff --git a/arkoala-arkts/framework/native/src/generated/real_impl.cc b/arkoala-arkts/framework/native/src/generated/real_impl.cc
index cf35022b88..9f648225d6 100644
--- a/arkoala-arkts/framework/native/src/generated/real_impl.cc
+++ b/arkoala-arkts/framework/native/src/generated/real_impl.cc
@@ -1288,6 +1288,73 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     {
     }
     } // ButtonAttributeModifier
+    namespace CalendarModifier {
+    Ark_NativePointer ConstructImpl(Ark_Int32 id,
+                                    Ark_Int32 flags)
+    {
+        return {};
+    }
+    } // CalendarModifier
+    namespace CalendarInterfaceModifier {
+    void SetCalendarOptionsImpl(Ark_NativePointer node,
+                                const Ark_CalendarRequestedMonths* value)
+    {
+    }
+    } // CalendarInterfaceModifier
+    namespace CalendarAttributeModifier {
+    void ShowLunarImpl(Ark_NativePointer node,
+                       const Opt_Boolean* value)
+    {
+    }
+    void ShowHolidayImpl(Ark_NativePointer node,
+                         const Opt_Boolean* value)
+    {
+    }
+    void NeedSlideImpl(Ark_NativePointer node,
+                       const Opt_Boolean* value)
+    {
+    }
+    void StartOfWeekImpl(Ark_NativePointer node,
+                         const Opt_Number* value)
+    {
+    }
+    void OffDaysImpl(Ark_NativePointer node,
+                     const Opt_Number* value)
+    {
+    }
+    void DirectionImpl(Ark_NativePointer node,
+                       const Opt_Axis* value)
+    {
+    }
+    void CurrentDayStyleImpl(Ark_NativePointer node,
+                             const Opt_CurrentDayStyle* value)
+    {
+    }
+    void NonCurrentDayStyleImpl(Ark_NativePointer node,
+                                const Opt_NonCurrentDayStyle* value)
+    {
+    }
+    void TodayStyleImpl(Ark_NativePointer node,
+                        const Opt_TodayStyle* value)
+    {
+    }
+    void WeekStyleImpl(Ark_NativePointer node,
+                       const Opt_WeekStyle* value)
+    {
+    }
+    void WorkStateStyleImpl(Ark_NativePointer node,
+                            const Opt_WorkStateStyle* value)
+    {
+    }
+    void OnSelectChangeImpl(Ark_NativePointer node,
+                            const Opt_Callback_CalendarSelectedDate_Void* value)
+    {
+    }
+    void OnRequestDataImpl(Ark_NativePointer node,
+                           const Opt_Callback_CalendarRequestedData_Void* value)
+    {
+    }
+    } // CalendarAttributeModifier
     namespace CalendarPickerModifier {
     Ark_NativePointer ConstructImpl(Ark_Int32 id,
                                     Ark_Int32 flags)
@@ -7931,6 +7998,28 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return &ArkUIButtonModifierImpl;
     }
 
+    const GENERATED_ArkUICalendarModifier* GetCalendarModifier()
+    {
+        static const GENERATED_ArkUICalendarModifier ArkUICalendarModifierImpl {
+            CalendarModifier::ConstructImpl,
+            CalendarInterfaceModifier::SetCalendarOptionsImpl,
+            CalendarAttributeModifier::ShowLunarImpl,
+            CalendarAttributeModifier::ShowHolidayImpl,
+            CalendarAttributeModifier::NeedSlideImpl,
+            CalendarAttributeModifier::StartOfWeekImpl,
+            CalendarAttributeModifier::OffDaysImpl,
+            CalendarAttributeModifier::DirectionImpl,
+            CalendarAttributeModifier::CurrentDayStyleImpl,
+            CalendarAttributeModifier::NonCurrentDayStyleImpl,
+            CalendarAttributeModifier::TodayStyleImpl,
+            CalendarAttributeModifier::WeekStyleImpl,
+            CalendarAttributeModifier::WorkStateStyleImpl,
+            CalendarAttributeModifier::OnSelectChangeImpl,
+            CalendarAttributeModifier::OnRequestDataImpl,
+        };
+        return &ArkUICalendarModifierImpl;
+    }
+
     const GENERATED_ArkUICalendarPickerModifier* GetCalendarPickerModifier()
     {
         static const GENERATED_ArkUICalendarPickerModifier ArkUICalendarPickerModifierImpl {
@@ -10077,6 +10166,7 @@ namespace OHOS::Ace::NG::GeneratedModifier {
             GetBaseSpanModifier,
             GetBlankModifier,
             GetButtonModifier,
+            GetCalendarModifier,
             GetCalendarPickerModifier,
             GetCanvasModifier,
             GetCheckboxModifier,
@@ -10441,30 +10531,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return reinterpret_cast<void *>(&DestroyPeerImpl);
     }
     } // BaseContextAccessor
-    namespace BaseCustomDialogAccessor {
-    void DestroyPeerImpl(Ark_BaseCustomDialog peer)
-    {
-        auto peerImpl = reinterpret_cast<BaseCustomDialogPeerImpl *>(peer);
-        if (peerImpl) {
-            delete peerImpl;
-        }
-    }
-    Ark_BaseCustomDialog ConstructImpl(const Opt_Boolean* useSharedStorage,
-                                       const Opt_CustomObject* storage)
-    {
-        return {};
-    }
-    Ark_NativePointer GetFinalizerImpl()
-    {
-        return reinterpret_cast<void *>(&DestroyPeerImpl);
-    }
-    Ark_CustomObject $_instantiateImpl(const Callback_T* factory,
-                                       const Opt_CustomObject* initializers,
-                                       const Opt_Callback_Void* content)
-    {
-        return {};
-    }
-    } // BaseCustomDialogAccessor
     namespace BaseEventAccessor {
     void DestroyPeerImpl(Ark_BaseEvent peer)
     {
@@ -10740,6 +10806,30 @@ namespace OHOS::Ace::NG::GeneratedModifier {
         return {};
     }
     } // BuilderNodeOpsAccessor
+    namespace CalendarControllerAccessor {
+    void DestroyPeerImpl(Ark_CalendarController peer)
+    {
+        auto peerImpl = reinterpret_cast<CalendarControllerPeerImpl *>(peer);
+        if (peerImpl) {
+            delete peerImpl;
+        }
+    }
+    Ark_CalendarController ConstructImpl()
+    {
+        return {};
+    }
+    Ark_NativePointer GetFinalizerImpl()
+    {
+        return reinterpret_cast<void *>(&DestroyPeerImpl);
+    }
+    void BackToTodayImpl(Ark_CalendarController peer)
+    {
+    }
+    void GoToImpl(Ark_CalendarController peer,
+                  const Ark_CalendarSelectedDate* date)
+    {
+    }
+    } // CalendarControllerAccessor
     namespace CalendarPickerDialogAccessor {
     void DestroyPeerImpl(Ark_CalendarPickerDialog peer)
     {
@@ -19942,36 +20032,32 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     {
         return {};
     }
-    Ark_TransitionEffect GetIDENTITYImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetIDENTITYImpl()
     {
         return {};
     }
-    void SetIDENTITYImpl(Ark_TransitionEffect peer,
-                         Ark_TransitionEffect IDENTITY)
+    void SetIDENTITYImpl(Ark_TransitionEffect IDENTITY)
     {
     }
-    Ark_TransitionEffect GetOPACITYImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetOPACITYImpl()
     {
         return {};
     }
-    void SetOPACITYImpl(Ark_TransitionEffect peer,
-                        Ark_TransitionEffect OPACITY)
+    void SetOPACITYImpl(Ark_TransitionEffect OPACITY)
     {
     }
-    Ark_TransitionEffect GetSLIDEImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetSLIDEImpl()
     {
         return {};
     }
-    void SetSLIDEImpl(Ark_TransitionEffect peer,
-                      Ark_TransitionEffect SLIDE)
+    void SetSLIDEImpl(Ark_TransitionEffect SLIDE)
     {
     }
-    Ark_TransitionEffect GetSLIDE_SWITCHImpl(Ark_TransitionEffect peer)
+    Ark_TransitionEffect GetSLIDE_SWITCHImpl()
     {
         return {};
     }
-    void SetSLIDE_SWITCHImpl(Ark_TransitionEffect peer,
-                             Ark_TransitionEffect SLIDE_SWITCH)
+    void SetSLIDE_SWITCHImpl(Ark_TransitionEffect SLIDE_SWITCH)
     {
     }
     } // TransitionEffectAccessor
@@ -21065,20 +21151,6 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     struct BaseContextPeer {
         virtual ~BaseContextPeer() = default;
     };
-    const GENERATED_ArkUIBaseCustomDialogAccessor* GetBaseCustomDialogAccessor()
-    {
-        static const GENERATED_ArkUIBaseCustomDialogAccessor BaseCustomDialogAccessorImpl {
-            BaseCustomDialogAccessor::DestroyPeerImpl,
-            BaseCustomDialogAccessor::ConstructImpl,
-            BaseCustomDialogAccessor::GetFinalizerImpl,
-            BaseCustomDialogAccessor::$_instantiateImpl,
-        };
-        return &BaseCustomDialogAccessorImpl;
-    }
-
-    struct BaseCustomDialogPeer {
-        virtual ~BaseCustomDialogPeer() = default;
-    };
     const GENERATED_ArkUIBaseEventAccessor* GetBaseEventAccessor()
     {
         static const GENERATED_ArkUIBaseEventAccessor BaseEventAccessorImpl {
@@ -21199,6 +21271,21 @@ namespace OHOS::Ace::NG::GeneratedModifier {
     struct BuilderNodeOpsPeer {
         virtual ~BuilderNodeOpsPeer() = default;
     };
+    const GENERATED_ArkUICalendarControllerAccessor* GetCalendarControllerAccessor()
+    {
+        static const GENERATED_ArkUICalendarControllerAccessor CalendarControllerAccessorImpl {
+            CalendarControllerAccessor::DestroyPeerImpl,
+            CalendarControllerAccessor::ConstructImpl,
+            CalendarControllerAccessor::GetFinalizerImpl,
+            CalendarControllerAccessor::BackToTodayImpl,
+            CalendarControllerAccessor::GoToImpl,
+        };
+        return &CalendarControllerAccessorImpl;
+    }
+
+    struct CalendarControllerPeer {
+        virtual ~CalendarControllerPeer() = default;
+    };
     const GENERATED_ArkUICalendarPickerDialogAccessor* GetCalendarPickerDialogAccessor()
     {
         static const GENERATED_ArkUICalendarPickerDialogAccessor CalendarPickerDialogAccessorImpl {
@@ -25456,13 +25543,13 @@ namespace OHOS::Ace::NG::GeneratedModifier {
             GetAxisEventAccessor,
             GetBackgroundColorStyleAccessor,
             GetBaseContextAccessor,
-            GetBaseCustomDialogAccessor,
             GetBaseEventAccessor,
             GetBaseGestureEventAccessor,
             GetBaselineOffsetStyleAccessor,
             GetBaseShapeAccessor,
             GetBounceSymbolEffectAccessor,
             GetBuilderNodeOpsAccessor,
+            GetCalendarControllerAccessor,
             GetCalendarPickerDialogAccessor,
             GetCanvasGradientAccessor,
             GetCanvasPathAccessor,
-- 
Gitee