diff --git a/packages/core/src/generators/Generate.ts b/packages/core/src/generators/Generate.ts
index ad1b17354d..4a8d9adebe 100644
--- a/packages/core/src/generators/Generate.ts
+++ b/packages/core/src/generators/Generate.ts
@@ -28,9 +28,7 @@ import { generateJsonSchema } from './schema';
 import { createControlElement, generateDefaultUISchema } from './uischema';
 
 export const Generate: {
-  // TODO fix @typescript-eslint/ban-types
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  jsonSchema(instance: Object, options?: any): JsonSchema;
+  jsonSchema(instance: unknown, options?: any): JsonSchema;
   uiSchema(
     jsonSchema: JsonSchema,
     layoutType?: string,
diff --git a/packages/core/src/generators/schema.ts b/packages/core/src/generators/schema.ts
index f3b1d2324b..623966e97f 100644
--- a/packages/core/src/generators/schema.ts
+++ b/packages/core/src/generators/schema.ts
@@ -52,9 +52,7 @@ class Gen {
     private findOption: (props: Properties) => (optionName: string) => any
   ) {}
 
-  // TODO fix @typescript-eslint/ban-types
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  schemaObject = (data: Object): JsonSchema4 => {
+  schemaObject = (data: Record<string, any>): JsonSchema4 => {
     const props: Properties = this.properties(data);
     const schema: JsonSchema4 = {
       type: 'object',
@@ -140,14 +138,12 @@ class Gen {
 
 /**
  * Generate a JSON schema based on the given data and any additional options.
- * @param {Object} instance the data to create a JSON schema for
+ * @param {unknown} instance the data to create a JSON schema for
  * @param {any} options any additional options that may alter the generated JSON schema
  * @returns {JsonSchema} the generated schema
  */
 export const generateJsonSchema = (
-  // TODO fix @typescript-eslint/ban-types
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  instance: Object,
+  instance: unknown,
   options: any = {}
 ): JsonSchema4 => {
   const findOption =
@@ -177,5 +173,5 @@ export const generateJsonSchema = (
 
   const gen = new Gen(findOption);
 
-  return gen.schemaObject(instance);
+  return gen.property(instance);
 };
diff --git a/packages/core/src/generators/uischema.ts b/packages/core/src/generators/uischema.ts
index bb8fdec2f9..ff91662841 100644
--- a/packages/core/src/generators/uischema.ts
+++ b/packages/core/src/generators/uischema.ts
@@ -225,4 +225,4 @@ export const generateDefaultUISchema = (
   wrapInLayoutIfNecessary(
     generateUISchema(jsonSchema, [], prefix, '', layoutType, rootSchema),
     layoutType
-  );
+  ) ?? createLayout(layoutType);
diff --git a/packages/core/test/generators/schema.test.ts b/packages/core/test/generators/schema.test.ts
index 679defefa3..13ecf543b9 100644
--- a/packages/core/test/generators/schema.test.ts
+++ b/packages/core/test/generators/schema.test.ts
@@ -26,6 +26,38 @@ import test from 'ava';
 
 import { generateJsonSchema } from '../../src/generators/schema';
 
+test('default schema generation root primitive types', (t) => {
+  t.deepEqual(generateJsonSchema(undefined), {});
+  t.deepEqual(generateJsonSchema('hello'), {
+    type: 'string',
+  });
+  t.deepEqual(generateJsonSchema(42), {
+    type: 'integer',
+  });
+  t.deepEqual(generateJsonSchema(3.14), {
+    type: 'number',
+  });
+  t.deepEqual(generateJsonSchema(true), {
+    type: 'boolean',
+  });
+  t.deepEqual(generateJsonSchema(null), {
+    type: 'null',
+  });
+});
+
+test('default schema generation root array types', (t) => {
+  t.deepEqual(generateJsonSchema([]), {
+    type: 'array',
+    items: {},
+  });
+  t.deepEqual(generateJsonSchema([1, 2]), {
+    type: 'array',
+    items: {
+      type: 'integer',
+    },
+  });
+});
+
 test('default schema generation basic types', (t) => {
   const instance: any = {
     boolean: false,
diff --git a/packages/core/test/generators/uischema.test.ts b/packages/core/test/generators/uischema.test.ts
index 904f3b70b4..024c1e177f 100644
--- a/packages/core/test/generators/uischema.test.ts
+++ b/packages/core/test/generators/uischema.test.ts
@@ -496,19 +496,28 @@ test('generate unnamed array control w/o type', (t) => {
 
 test('generate for empty schema', (t) => {
   const schema: JsonSchema = {};
-  const uischema: Layout = null;
+  const uischema: Layout = {
+    type: 'VerticalLayout',
+    elements: [],
+  };
   t.deepEqual(generateDefaultUISchema(schema), uischema);
 });
 
 test('generate for null schema', (t) => {
   const schema: JsonSchema = null;
-  const uischema: Layout = null;
+  const uischema: Layout = {
+    type: 'VerticalLayout',
+    elements: [],
+  };
   t.deepEqual(generateDefaultUISchema(schema), uischema);
 });
 
 test('generate for undefined schema', (t) => {
   const schema: JsonSchema = undefined;
-  const uischema: Layout = null;
+  const uischema: Layout = {
+    type: 'VerticalLayout',
+    elements: [],
+  };
   t.deepEqual(generateDefaultUISchema(schema), uischema);
 });
 
diff --git a/packages/vue-vuetify/dev/components/ExampleForm.vue b/packages/vue-vuetify/dev/components/ExampleForm.vue
index 25a2e4f6bc..4036503c4d 100644
--- a/packages/vue-vuetify/dev/components/ExampleForm.vue
+++ b/packages/vue-vuetify/dev/components/ExampleForm.vue
@@ -50,12 +50,16 @@ const resolvedSchema = shallowReactive<ResolvedSchema>({
   error: undefined,
 });
 
-const emits = defineEmits(['jsfchange']);
+const emits = defineEmits(['jsfchange', 'update:data']);
 
 const onChange = (event: JsonFormsChangeEvent): void => {
   emits('jsfchange', event);
 };
 
+const onUpdateData = (data: any): void => {
+  emits('update:data', data);
+};
+
 watch(
   () => props.state.schema,
   (schema) => {
@@ -101,6 +105,7 @@ const properties = computed<JsonFormsProps>(() => ({
       v-if="resolvedSchema.resolved && resolvedSchema.error === undefined"
       v-bind="properties"
       @change="onChange"
+      @update:data="onUpdateData"
     ></json-forms>
     <v-container v-else>
       <v-row
diff --git a/packages/vue-vuetify/dev/views/ExampleView.vue b/packages/vue-vuetify/dev/views/ExampleView.vue
index 653993197b..b95099015e 100644
--- a/packages/vue-vuetify/dev/views/ExampleView.vue
+++ b/packages/vue-vuetify/dev/views/ExampleView.vue
@@ -94,11 +94,14 @@ const onChange = (event: JsonFormsChangeEvent): void => {
       monaco.Uri.parse(toDataUri(props.example.name)),
       event.data !== undefined ? JSON.stringify(event.data, null, 2) : '',
     );
-    state.data = event.data;
   }
   errors.value = event.errors;
 };
 
+const onDataChange = (data: any): void => {
+  state.data = data;
+};
+
 const reloadMonacoSchema = () => {
   const example = find(
     examples,
@@ -346,7 +349,11 @@ const handleAction = (action: Action) => {
                         </v-toolbar>
                       </v-card-title>
                       <v-divider class="mx-4"></v-divider>
-                      <example-form :state="state" @jsfchange="onChange" />
+                      <example-form
+                        :state="state"
+                        @update:data="onDataChange"
+                        @jsfchange="onChange"
+                      />
                     </v-card>
                   </pane>
                   <pane>
@@ -392,7 +399,12 @@ const handleAction = (action: Action) => {
                   </pane>
                 </splitpanes>
 
-                <example-form :state="state" @jsfchange="onChange" v-else />
+                <example-form
+                  :state="state"
+                  @update:data="onDataChange"
+                  @jsfchange="onChange"
+                  v-else
+                />
               </div>
             </v-card>
           </v-window-item>
@@ -505,7 +517,11 @@ const handleAction = (action: Action) => {
       </v-snackbar>
     </v-container>
     <div class="json-forms" v-else>
-      <example-form :state="state" @jsfchange="onChange" />
+      <example-form
+        :state="state"
+        @update:data="onDataChange"
+        @jsfchange="onChange"
+      />
     </div>
   </div>
 </template>
diff --git a/packages/vue/README.md b/packages/vue/README.md
index a2b4bf10fc..2e87b8b327 100644
--- a/packages/vue/README.md
+++ b/packages/vue/README.md
@@ -37,12 +37,13 @@ Optional props:
 Events:
 
 - `change: {data: any; errors: AJVError[]}` - Whenever data and/or errors change this event is emitted.
+- `update:data: any` - Emits the current data alongside `change`, enabling `v-model:data`.
 
 Example:
 
 ```html
 <json-forms
-  :data="data"
+  v-model:data="data"
   :renderers="renderers"
   :schema="schema"
   :uischema="uischema"
@@ -82,7 +83,7 @@ export default defineComponent({
   },
   methods: {
     onChange(event: JsonFormsChangeEvent) {
-      this.data = event.data;
+      console.log(event);
     },
   },
 });
diff --git a/packages/vue/src/components/JsonForms.vue b/packages/vue/src/components/JsonForms.vue
index d21863e574..f092002ad5 100644
--- a/packages/vue/src/components/JsonForms.vue
+++ b/packages/vue/src/components/JsonForms.vue
@@ -7,40 +7,39 @@
 </template>
 
 <script lang="ts">
-import { PropType, reactive, defineComponent } from 'vue';
 import {
-  coreReducer,
   Actions,
-  Generate,
   configReducer,
-  JsonSchema,
-  UISchemaElement,
-  ValidationMode,
-  JsonFormsCore,
-  JsonFormsUISchemaRegistryEntry,
-  JsonFormsRendererRegistryEntry,
-  JsonFormsCellRendererRegistryEntry,
   CoreActions,
+  coreReducer,
+  defaultMiddleware,
+  Generate,
   i18nReducer,
+  JsonFormsCellRendererRegistryEntry,
+  JsonFormsCore,
   JsonFormsI18nState,
-  defaultMiddleware,
-  Middleware,
+  JsonFormsRendererRegistryEntry,
   JsonFormsSubStates,
+  JsonFormsUISchemaRegistryEntry,
+  JsonSchema,
+  Middleware,
+  UISchemaElement,
+  ValidationMode,
 } from '@jsonforms/core';
+import isEqual from 'lodash/isEqual';
+import { defineComponent, PropType, reactive } from 'vue';
 import { JsonFormsChangeEvent, MaybeReadonly } from '../types';
 import DispatchRenderer from './DispatchRenderer.vue';
 
 import type Ajv from 'ajv';
 import type { ErrorObject } from 'ajv';
 
-// TODO fix @typescript-eslint/ban-types
-// eslint-disable-next-line @typescript-eslint/ban-types
-const isObject = (elem: any): elem is Object => {
-  return elem && typeof elem === 'object';
-};
-
 const EMPTY: ErrorObject[] = reactive([]);
 
+const getSchemaGeneratorInput = (data: any) => (data === undefined ? {} : data);
+const generateUISchema = (schema: JsonSchema) =>
+  Generate.uiSchema(schema, undefined, undefined, schema);
+
 export default defineComponent({
   name: 'JsonForms',
   components: {
@@ -121,15 +120,12 @@ export default defineComponent({
       default: defaultMiddleware,
     },
   },
-  emits: ['change'],
+  emits: ['change', 'update:data'],
   data() {
     const dataToUse = this.data;
-    const generatorData = isObject(dataToUse) ? dataToUse : {};
     const schemaToUse: JsonSchema =
-      this.schema ?? Generate.jsonSchema(generatorData);
-    const uischemaToUse =
-      this.uischema ??
-      Generate.uiSchema(schemaToUse, undefined, undefined, schemaToUse);
+      this.schema ?? Generate.jsonSchema(getSchemaGeneratorInput(dataToUse));
+    const uischemaToUse = this.uischema ?? generateUISchema(schemaToUse);
     const initCore = (): JsonFormsCore => {
       const initialCore = {
         data: dataToUse,
@@ -189,29 +185,31 @@ export default defineComponent({
   },
   watch: {
     schema(newSchema) {
-      const generatorData = isObject(this.data) ? this.data : {};
-      this.schemaToUse = newSchema ?? Generate.jsonSchema(generatorData);
+      this.schemaToUse =
+        newSchema ??
+        Generate.jsonSchema(getSchemaGeneratorInput(this.dataToUse));
       if (!this.uischema) {
-        this.uischemaToUse = Generate.uiSchema(
-          this.schemaToUse,
-          undefined,
-          undefined,
-          this.schemaToUse
-        );
+        this.uischemaToUse = generateUISchema(this.schemaToUse);
       }
     },
     uischema(newUischema) {
-      this.uischemaToUse =
-        newUischema ??
-        Generate.uiSchema(
-          this.schemaToUse,
-          undefined,
-          undefined,
-          this.schemaToUse
-        );
+      this.uischemaToUse = newUischema ?? generateUISchema(this.schemaToUse);
     },
     data(newData) {
+      const isSameAsCurrentData = newData === this.jsonforms.core.data;
       this.dataToUse = newData;
+
+      if (!this.schema && !isSameAsCurrentData) {
+        const nextSchema = Generate.jsonSchema(
+          getSchemaGeneratorInput(this.dataToUse)
+        );
+        if (!isEqual(nextSchema, this.schemaToUse)) {
+          this.schemaToUse = nextSchema;
+          if (!this.uischema) {
+            this.uischemaToUse = generateUISchema(this.schemaToUse);
+          }
+        }
+      }
     },
     renderers(newRenderers) {
       this.jsonforms.renderers = newRenderers;
@@ -251,6 +249,7 @@ export default defineComponent({
       );
     },
     eventToEmit(newEvent) {
+      this.$emit('update:data', newEvent.data);
       this.$emit('change', newEvent);
     },
     i18n: {
diff --git a/packages/vue/tests/unit/JsonForms.spec.ts b/packages/vue/tests/unit/JsonForms.spec.ts
index b39e505273..ac35645137 100644
--- a/packages/vue/tests/unit/JsonForms.spec.ts
+++ b/packages/vue/tests/unit/JsonForms.spec.ts
@@ -1,5 +1,10 @@
-import { JsonFormsUISchemaRegistryEntry, Generate } from '@jsonforms/core';
+import {
+  Actions,
+  JsonFormsUISchemaRegistryEntry,
+  Generate,
+} from '@jsonforms/core';
 import { shallowMount } from '@vue/test-utils';
+import { nextTick } from 'vue';
 import { JsonForms } from '../../src';
 import { bindings } from '../testHelper';
 
@@ -30,6 +35,20 @@ describe('JsonForms.vue', () => {
     );
   });
 
+  it('generates schema for primitive root data', () => {
+    const data = 5.5;
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+    expect((wrapper.vm as any).jsonforms.core.schema).toEqual(
+      Generate.jsonSchema(data)
+    );
+  });
+
   it('generates ui schema when not given via prop', () => {
     const data = { number: 5.5 };
     const schema = {
@@ -47,4 +66,164 @@ describe('JsonForms.vue', () => {
       Generate.uiSchema(schema)
     );
   });
+
+  it('preserves undefined root data when the data prop is cleared', async () => {
+    const data = { number: 5.5 };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    await wrapper.setProps({ data: undefined });
+
+    expect((wrapper.vm as any).jsonforms.core.data).toBeUndefined();
+
+    const changeEvents = wrapper.emitted('change');
+    const latestChangeEvent: any = changeEvents?.[changeEvents.length - 1]?.[0];
+    expect(latestChangeEvent?.data).toBeUndefined();
+  });
+
+  it('emits update:data when the form data changes', async () => {
+    const data = { number: 5.5 };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    (wrapper.vm as any).dispatch(Actions.update('number', () => 6));
+    await nextTick();
+
+    const updateEvents = wrapper.emitted('update:data');
+    expect(updateEvents?.[updateEvents.length - 1]?.[0]).toEqual({ number: 6 });
+  });
+
+  it('keeps the data prop authoritative when additionalErrors change', async () => {
+    const data = { number: 5.5 };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    (wrapper.vm as any).dispatch(Actions.update('number', () => 6));
+    await nextTick();
+
+    await wrapper.setProps({
+      additionalErrors: [
+        {
+          instancePath: '/number',
+          schemaPath: '#/properties/number/minimum',
+          keyword: 'minimum',
+          params: { comparison: '>=', limit: 7 },
+        },
+      ],
+    });
+
+    expect((wrapper.vm as any).jsonforms.core.data).toEqual(data);
+  });
+
+  it('preserves edited data when v-model:data is used and additionalErrors change', async () => {
+    const data = { number: 5.5 };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    (wrapper.vm as any).dispatch(Actions.update('number', () => 6));
+    await nextTick();
+
+    const updateEvents = wrapper.emitted('update:data');
+    const updatedData = updateEvents?.[updateEvents.length - 1]?.[0];
+    await wrapper.setProps({ data: updatedData });
+
+    await wrapper.setProps({
+      additionalErrors: [
+        {
+          instancePath: '/number',
+          schemaPath: '#/properties/number/minimum',
+          keyword: 'minimum',
+          params: { comparison: '>=', limit: 7 },
+        },
+      ],
+    });
+
+    expect((wrapper.vm as any).jsonforms.core.data).toEqual({ number: 6 });
+  });
+
+  it('does not regenerate schema and uischema when the parent passes back the current form data', async () => {
+    const data = { number: 5.5 };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    const initialSchema = (wrapper.vm as any).schemaToUse;
+    const initialUiSchema = (wrapper.vm as any).uischemaToUse;
+
+    (wrapper.vm as any).dispatch(Actions.update('number', () => 6));
+    await nextTick();
+
+    await wrapper.setProps({
+      data: (wrapper.vm as any).jsonforms.core.data,
+    });
+
+    expect((wrapper.vm as any).schemaToUse).toBe(initialSchema);
+    expect((wrapper.vm as any).uischemaToUse).toBe(initialUiSchema);
+  });
+
+  it('regenerates schema and uischema for external data changes', async () => {
+    const data = { number: 5.5 };
+    const nextData = { number: 5.5, text: 'hello' };
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    const initialSchema = (wrapper.vm as any).schemaToUse;
+    const initialUiSchema = (wrapper.vm as any).uischemaToUse;
+
+    await wrapper.setProps({ data: nextData });
+
+    expect((wrapper.vm as any).schemaToUse).not.toBe(initialSchema);
+    expect((wrapper.vm as any).uischemaToUse).not.toBe(initialUiSchema);
+    expect((wrapper.vm as any).jsonforms.core.schema).toEqual(
+      Generate.jsonSchema(nextData)
+    );
+  });
+
+  it('does not regenerate schema and uischema when external data keeps the same schema', async () => {
+    const data = 'hello';
+    const renderers: JsonFormsUISchemaRegistryEntry[] = [];
+    const wrapper = shallowMount(
+      JsonForms,
+      bindings({
+        props: { data, renderers },
+      })
+    );
+
+    const initialSchema = (wrapper.vm as any).schemaToUse;
+    const initialUiSchema = (wrapper.vm as any).uischemaToUse;
+
+    await wrapper.setProps({ data: 'world' });
+
+    expect((wrapper.vm as any).schemaToUse).toBe(initialSchema);
+    expect((wrapper.vm as any).uischemaToUse).toBe(initialUiSchema);
+  });
 });