@knime/jsonforms 1.8.6 → 1.8.7

package/dist/src/higherOrderComponents/control/controlToRenderer.d.ts

@@ -1,6 +1,13 @@
 import { ParameterizedComponent, RendererParams } from '../types';
 import { VueControl } from './types';
+import { PerformExternalValidation } from './validation/types';
 /**
  * The last transformation step, since JSONForms expects renderers with core params.
  */
-export declare const controlToRenderer: (component: VueControl<any>, asyncSetup?: () => Promise<void>) => ParameterizedComponent<RendererParams>;
+export declare const controlToRenderer: ({ component, asyncSetup, config, }: {
+    component: VueControl<unknown>;
+    asyncSetup?: () => Promise<void>;
+    config?: {
+        performExternalValidation?: PerformExternalValidation<unknown>;
+    };
+}) => ParameterizedComponent<RendererParams>;

package/dist/src/higherOrderComponents/control/errorMessage/ErrorLine.vue.d.ts

@@ -1,15 +1,5 @@
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
+type __VLS_Props = {
     error: string;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
-    error: string;
-}>>>, {}, {}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
 };
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/higherOrderComponents/control/errorMessage/ErrorMessages.vue.d.ts

@@ -1,20 +1,21 @@
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<{
-    errors: string[];
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
-    errors: string[];
-}>>>, {}, {}>, {
-    default?(_: {}): any;
-}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+type __VLS_Props = {
+    errors: Array<string>;
+    fill?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
     };
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    fill: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/src/higherOrderComponents/control/errorMessage/withErrorMessage.d.ts

@@ -1,4 +1,11 @@
 import { VNode } from 'vue';
 import { VueControl, VueControlProps } from '../types';
-export declare const addErrorMessageToVNode: (vNode: VNode, props: Pick<VueControlProps<any>, "messages">) => VNode | VNode[];
-export declare const withErrorMessage: <D>({ control, tester, name, __asyncSetup, }: import('../util').SpecialControlRenderer<VueControl<D>>) => import('../util').SpecialControlRenderer<VueControl<D>>;
+export declare const addErrorMessageToVNode: ({ fill }: {
+    fill: boolean;
+}) => (vNode: VNode, props: Pick<VueControlProps<unknown>, "messages">) => VNode | VNode[];
+export declare const withErrorMessage: (config?: {
+    /**
+     * Set to true if the renderer should grow within its parent
+     */
+    fill: boolean;
+}) => <D>({ control, tester, name, __asyncSetup, }: import('..').SpecialControlRenderer<VueControl<D>>) => import('..').SpecialControlRenderer<VueControl<D>>;

package/dist/src/higherOrderComponents/control/index.d.ts

@@ -4,4 +4,5 @@ export type * from './types';
 export * from './withLabel';
 export * from './controlToRenderer';
 export * from './util';
+export type { PerformExternalValidation } from './validation/types';
 export { LabeledControl, ErrorMessages };

package/dist/src/higherOrderComponents/control/types.d.ts

@@ -8,8 +8,12 @@ import { ValidationSettings } from './validation/types';
 export type VueControlProps<D> = {
     control: {
         data: D;
+        uischema: {
+            providedOptions?: string[];
+            id?: string;
+        };
     } & Omit<ReturnType<typeof useJsonFormsControl>["control"]["value"], "data">;
-    handleChange: (path: string, value: any) => void;
+    handleChange: (path: string, value: unknown) => void;
     changeValue: (newValue: D) => void;
     disabled: boolean;
     labelForId?: null;
@@ -21,14 +25,14 @@ export type ControlSlots = {
     buttons?: (props: {
         controlHTMLElement?: HTMLElement | null;
         hover: boolean;
-    }) => any[];
-    icon?: any;
+    }) => unknown[];
+    icon?: unknown;
 };
 export type VueControlParamsFromProps<P> = {
     props: P;
     slots: ControlSlots;
 };
-export type PropsToComponent<P extends Record<string, any>> = ParameterizedComponent<VueControlParamsFromProps<P>>;
+export type PropsToComponent<P extends Record<string, unknown>> = ParameterizedComponent<VueControlParamsFromProps<P>>;
 export type VueControl<D> = PropsToComponent<VueControlProps<D>>;
 export type VueControlRenderer = NamedTester & {
     control: VueControl<any>;

package/dist/src/higherOrderComponents/control/util.d.ts

@@ -1,59 +1,39 @@
 import { Component, PropType, SetupContext, SlotsType, VNode } from 'vue';
+import { VueLayout, VueLayoutRenderer } from '../layout';
 import { ControlSlots, VueControl, VueControlProps, VueControlRenderer } from './types';
 export declare const controlProps: {
     control: {
-        type: PropType<{
-            data: any;
-        } & Omit<{
-            uischema: import('@jsonforms/core').ControlElement;
-            schema: NonNullable<import('@jsonforms/core').JsonSchema>;
-            path: string;
-            enabled: boolean;
-            renderers: import('@jsonforms/core').JsonFormsRendererRegistryEntry[];
-            cells: import('@jsonforms/core').JsonFormsCellRendererRegistryEntry[] & {
-                tester: import('@jsonforms/core').RankedTester;
-                cell: any;
-            }[];
-            config: any;
-            label: string;
-            description: string;
-            required: NonNullable<boolean | undefined>;
-            i18nKeyPrefix: string;
-            errors: string;
-            data: any;
-            rootSchema: NonNullable<import('@jsonforms/core').JsonSchema>;
-            id: string;
-            visible: boolean;
-        }, "data">>;
+        type: PropType<VueControlProps<never>["control"]>;
         required: boolean;
     };
     handleChange: {
-        type: PropType<(path: string, value: any) => void>;
+        type: PropType<VueControlProps<never>["handleChange"]>;
         required: boolean;
     };
     changeValue: {
-        type: PropType<(newValue: any) => void>;
+        type: PropType<VueControlProps<unknown>["changeValue"]>;
         required: boolean;
     };
     disabled: {
-        type: PropType<boolean>;
+        type: PropType<VueControlProps<never>["disabled"]>;
         required: boolean;
     };
     isValid: {
-        type: PropType<boolean>;
+        type: PropType<VueControlProps<never>["isValid"]>;
         required: boolean;
     };
     messages: {
-        type: PropType<import('./validation/types').Messages>;
+        type: PropType<VueControlProps<never>["messages"]>;
         required: boolean;
     };
     onRegisterValidation: {
-        type: PropType<(validation: import('./validation/types').ValidationMethod<any>) => void>;
+        type: PropType<VueControlProps<never>["onRegisterValidation"]>;
         required: boolean;
     };
 };
-export declare const defineControl: <D>(setup: (props: VueControlProps<D>, ctx: SetupContext<any, SlotsType<ControlSlots>>) => () => VNode | null | VNode[]) => VueControl<D>;
+export declare const defineControl: <D>(setup: (props: VueControlProps<D>, ctx: SetupContext<unknown, SlotsType<ControlSlots>>) => () => VNode | null | VNode[]) => VueControl<D>;
 export declare const mapControls: (mapper: (control: VueControl<any>, key: string) => VueControl<any>) => <T extends Record<string, VueControlRenderer>>(cs: T) => T;
+export declare const mapLayouts: (mapper: (layout: VueLayout, key: string) => VueLayout) => <T extends Record<string, VueLayoutRenderer>>(ls: T) => T;
 export type SpecialControlRenderer<SpecialControl> = Omit<VueControlRenderer, "control"> & {
     control: SpecialControl;
 };

package/dist/src/higherOrderComponents/control/validation/types.d.ts

@@ -12,5 +12,10 @@ export type ValidationMethod<D> = MaybeRef<((value: D) => Messages) | null>;
 export type ValidationSettings<D> = {
     isValid: boolean;
     messages: Messages;
-    onRegisterValidation: (validation: ValidationMethod<D>) => void;
+    /**
+     * @param validation the validation method to register.
+     * @returns the cleanup callback with which the validation can be unregistered.
+     */
+    onRegisterValidation: (validation: ValidationMethod<D>) => () => void;
 };
+export type PerformExternalValidation<D> = (id: string, value: D) => Promise<string | null>;

package/dist/src/higherOrderComponents/control/validation/useValidation.d.ts

@@ -1,9 +1,12 @@
 import { Ref } from 'vue';
-import { Messages, ValidationMethod } from './types';
-export declare const useValidation: <T = any>({ data }: {
+import { Messages, PerformExternalValidation, ValidationMethod } from './types';
+export declare const useValidation: <T = unknown>({ data, options, performExternalValidation, }: {
     data: Ref<T>;
+    options: Ref<Record<string, any>>;
+    performExternalValidation?: PerformExternalValidation<unknown>;
 }) => {
     messages: import('vue').ComputedRef<Messages>;
     isValid: import('vue').ComputedRef<boolean>;
-    onRegisterValidation: (validationMethod: ValidationMethod<T>) => number;
+    onRegisterValidation: (validationMethod: ValidationMethod<T>) => () => void;
+    performExternalValidationDebounced: import('lodash-es').DebouncedFunc<(value: T) => void>;
 };

package/dist/src/higherOrderComponents/control/withLabel.d.ts

@@ -1,9 +1,11 @@
 import { PropsToComponent, VueControl, VueControlProps } from './types';
-import { SpecialControlRenderer } from './util';
 export type VueControlPropsForLabelContent<D> = Omit<VueControlProps<D>, "labelForId" | "messages"> & {
     labelForId: string;
 };
 export type VueControlThatRequiresLabelWrapper<D> = PropsToComponent<VueControlPropsForLabelContent<D>>;
-export declare const withLabel: <D>(renderer: SpecialControlRenderer<VueControlThatRequiresLabelWrapper<D>>, config?: {
+export type VueControlExposed = {
+    focus?: () => void;
+};
+export declare const withLabel: (config?: {
     fill: boolean;
-}) => SpecialControlRenderer<VueControl<D>>;
+}) => <D>({ control, tester, name, __asyncSetup, }: import('./util').SpecialControlRenderer<VueControlThatRequiresLabelWrapper<D>>) => import('./util').SpecialControlRenderer<VueControl<D>>;

package/dist/src/higherOrderComponents/layout/types.d.ts

@@ -7,7 +7,7 @@ import { NamedTester, ParameterizedComponent } from '../types';
 export type VueLayoutProps = {
     layout: ReturnType<typeof useJsonFormsLayout>["layout"]["value"] & {
         uischema: {
-            [K: string]: any;
+            [K: string]: never;
         };
     };
 };
@@ -17,7 +17,7 @@ export type VueLayoutProps = {
 export type LayoutSlots = {
     buttons?: (props: {
         hover: boolean;
-    }) => any[];
+    }) => unknown[];
 };
 export type VueLayout = ParameterizedComponent<{
     props: VueLayoutProps;

package/dist/src/higherOrderComponents/layout/util.d.ts

@@ -2,24 +2,8 @@ import { PropType, SetupContext, SlotsType, VNode } from 'vue';
 import { LayoutSlots, VueLayout, VueLayoutProps } from './types';
 export declare const layoutProps: {
     layout: {
-        type: PropType<{
-            uischema: NonNullable<import('@jsonforms/core').Layout & import('@jsonforms/core').UISchemaElement>;
-            schema: NonNullable<import('@jsonforms/core').JsonSchema>;
-            path: string;
-            enabled: boolean;
-            renderers: import('@jsonforms/core').JsonFormsRendererRegistryEntry[];
-            cells: import('@jsonforms/core').JsonFormsCellRendererRegistryEntry[];
-            config: any;
-            direction: NonNullable<"column" | "row">;
-            label: string;
-            data: any;
-            visible: boolean;
-        } & {
-            uischema: {
-                [K: string]: any;
-            };
-        }>;
+        type: PropType<VueLayoutProps["layout"]>;
         required: boolean;
     };
 };
-export declare const defineLayout: (setup: (props: VueLayoutProps, ctx: SetupContext<any, SlotsType<LayoutSlots>>) => () => VNode | null) => VueLayout;
+export declare const defineLayout: (setup: (props: VueLayoutProps, ctx: SetupContext<unknown, SlotsType<LayoutSlots>>) => () => VNode | null) => VueLayout;

package/dist/src/higherOrderComponents/types.d.ts

@@ -1,25 +1,26 @@
-import { Component } from 'vue';
+import { Component, ComputedOptions, EmitsOptions, MethodOptions } from 'vue';
 import { RankedTester } from '@jsonforms/core';
 import { RendererProps } from '@jsonforms/vue';
 export type ComponentParams = {
-    props: Record<string, any>;
-    slots: Record<string, any>;
+    props: object;
+    slots: Record<string, unknown>;
 };
 export type ParameterizedComponent<T extends ComponentParams> = Component<T["props"], // props
-any, // bindings
-any, // data
-any, // computed
-any, // methods
-any, // emits
+unknown, // bindings
+unknown, // data
+ComputedOptions, // computed
+MethodOptions, // methods
+// methods
+EmitsOptions | Record<string, unknown[]>, // emits
 T["slots"]>;
 export type RendererParams = {
     props: RendererProps;
-    slots: any;
+    slots: ComponentParams;
 };
 export type NamedTester = {
     tester: RankedTester;
     name: string;
 };
 export type NamedRenderer = NamedTester & {
-    renderer: any;
+    renderer: unknown;
 };

package/dist/src/index.d.ts

@@ -1,7 +1,8 @@
 import { default as JsonFormsDialog } from './JsonFormsDialog.vue';
 import { AlertParams } from './types/alert';
 import { Provided } from './types/provided';
-export { JsonFormsDialog, type Provided, type AlertParams };
+import { UiSchemaWithProvidedOptions } from './uiComponents/composables/useProvidedState';
+export { JsonFormsDialog, type Provided, type AlertParams, type UiSchemaWithProvidedOptions, };
 export * from './higherOrderComponents';
 export * from './renderers';
 export * from './constants';

package/dist/src/layoutComponents/Form.vue.d.ts

@@ -1,7 +1,15 @@
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
-    default?(_: {}): any;
-    "bottom-content"?(_: {}): any;
-}>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'bottom-content'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/dist/src/layoutComponents/HorizontalLayout.vue.d.ts

@@ -1,12 +1,3 @@
 import { VueLayoutProps } from '../higherOrderComponents/layout/types';
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<VueLayoutProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<VueLayoutProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<VueLayoutProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VueLayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/dist/src/layoutComponents/SectionLayout.vue.d.ts

@@ -1,19 +1,18 @@
 import { VueLayoutProps } from '../higherOrderComponents/layout/types';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<VueLayoutProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<VueLayoutProps>>>, {}, {}>, {
-    buttons?(_: {
-        hover: boolean;
-    }): any;
-}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        buttons?(_: {
+            hover: boolean;
+        }): any;
     };
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<VueLayoutProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VueLayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/src/layoutComponents/SettingsSubPanelLayout.vue.d.ts

@@ -1,12 +1,3 @@
 import { VueLayoutProps } from '../higherOrderComponents/layout/types';
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<VueLayoutProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<VueLayoutProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<VueLayoutProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VueLayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/dist/src/layoutComponents/VerticalLayout.vue.d.ts

@@ -1,12 +1,3 @@
 import { VueLayoutProps } from '../higherOrderComponents/layout/types';
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<VueLayoutProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<VueLayoutProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<VueLayoutProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VueLayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/dist/src/layoutComponents/VerticalLayoutBase.vue.d.ts

@@ -1,24 +1,22 @@
 import { UISchemaElement } from '@jsonforms/core';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<{
+type __VLS_Props = {
     elements: UISchemaElement[];
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
-    elements: UISchemaElement[];
-}>>>, {}, {}>, {
-    default?(_: {
-        element: UISchemaElement;
-        index: number;
-    }): any;
-}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            element: UISchemaElement;
+            index: number;
+        }): any;
     };
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/src/layoutComponents/index.d.ts

@@ -1,4 +1,5 @@
 import { default as Form } from './Form.vue';
 import { default as VerticalLayoutBase } from './VerticalLayoutBase.vue';
+import { default as SectionHeading } from './section/SectionHeading.vue';
 import { default as SettingsSubPanel } from './settingsSubPanel/SettingsSubPanel.vue';
-export { Form, VerticalLayoutBase, SettingsSubPanel };
+export { Form, VerticalLayoutBase, SettingsSubPanel, SectionHeading };

package/dist/src/layoutComponents/section/SectionHeading.vue.d.ts

@@ -1,20 +1,18 @@
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<{
+type __VLS_Props = {
     titleText: string;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
-    titleText: string;
-}>>>, {}, {}>, {
-    "right-buttons"?(_: {}): any;
-}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'right-buttons'?(_: {}): any;
     };
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/src/layoutComponents/settingsSubPanel/SettingsSubPanel.vue.d.ts

@@ -1,50 +1,31 @@
+import { InjectionKey, Ref } from 'vue';
 export type SettingsSubPanelProps = {
     showBackArrow?: boolean;
     hideButtonsWhenExpanded?: boolean;
     backgroundColorOverride?: string;
 };
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<SettingsSubPanelProps>, {
-    showBackArrow: boolean;
-    hideButtonsWhenExpanded: boolean;
-    backgroundColorOverride: string;
-}>, {
+/**
+ * Exported for tests
+ */
+export declare const subPanelDestInjectionKey: InjectionKey<Ref<HTMLElement | null>>;
+export declare const provideSideDrawerTeleportDest: (subPanelTeleportDest: Ref<HTMLElement | null>) => void;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<SettingsSubPanelProps, {
     expand: () => void;
     close: () => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<SettingsSubPanelProps>, {
-    showBackArrow: boolean;
-    hideButtonsWhenExpanded: boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SettingsSubPanelProps> & Readonly<{}>, {
     backgroundColorOverride: string;
-}>>>, {
     showBackArrow: boolean;
     hideButtonsWhenExpanded: boolean;
-    backgroundColorOverride: string;
-}, {}>, {
-    "expand-button"?(_: {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    'expand-button'?(_: {
         expand: () => void;
     }): any;
     default?(_: {}): any;
-    "bottom-content"?(_: {}): any;
+    'bottom-content'?(_: {}): any;
 }>;
 export default _default;
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/src/layoutComponents/settingsSubPanel/SettingsSubPanelBackArrow.vue.d.ts

@@ -1,6 +1,11 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+type __VLS_Props = {
+    backgroundColorOverride?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>> & {
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: ((...args: any[]) => any) | undefined;
-}, {}, {}>;
+}>, {
+    backgroundColorOverride: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/src/loading/LoadingDialog.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/renderers/checkboxesRenderer.d.ts

@@ -1,3 +1 @@
-import { Tester } from '@jsonforms/core';
-export declare const checkboxesTester: Tester;
 export declare const checkboxesRenderer: import('..').SpecialControlRenderer<import('..').VueControl<string[]>>;

package/dist/src/renderers/dateTimeFormatPickerRenderer.d.ts

@@ -1,2 +1,2 @@
-export declare const dateTimeFormatPickerRenderer: import('../higherOrderComponents').SpecialControlRenderer<import('../higherOrderComponents').VueControl<string>>;
-export declare const dateTimeFormatPickerWithTypeRenderer: import('../higherOrderComponents').SpecialControlRenderer<import('../higherOrderComponents').VueControl<import('packages/components/src').DateTimeFormatModel>>;
+export declare const dateTimeFormatPickerRenderer: import('..').SpecialControlRenderer<import('..').VueControl<string>>;
+export declare const dateTimeFormatPickerWithTypeRenderer: import('..').SpecialControlRenderer<import('..').VueControl<import('packages/components/src').DateTimeFormatModel>>;