@vertesia/ui 0.56.0 → 0.58.0

package/lib/types/router/PathMatcher.d.ts

@@ -0,0 +1,35 @@
+import { PathMatchParams } from "./path";
+export interface PathMatch<T = any> {
+    params: PathMatchParams;
+    matchedSegments: string[];
+    remainingSegments?: string[];
+    value: T;
+}
+/**
+ * Path matcher which support :param and *wildcard segments.
+ * The wildcard segment is only supported as the last segment
+ */
+export declare class PathMatcher<T = any> {
+    tree: RootSegmentNode;
+    loadMapping(mapping: Record<string, T>): void;
+    addPath(path: string, value: T): void;
+    addSegments(segments: string[], value: T): void;
+    match(path: string | string[]): PathMatch<T> | null;
+}
+interface SegmentNode<T = any> {
+    name: string;
+    value?: T | undefined;
+    match(segment: string, params: PathMatchParams): SegmentNode<T> | null;
+}
+declare class ParentSegmentNode<T = any> implements SegmentNode<T> {
+    name: string;
+    value?: T | undefined;
+    children: Record<string, SegmentNode<T>>;
+    wildcard?: SegmentNode<T>;
+    constructor(name: string, value?: T | undefined);
+    match(segment: string, params: PathMatchParams): SegmentNode<T> | null;
+}
+declare class RootSegmentNode<T = any> extends ParentSegmentNode<T> {
+    constructor();
+}
+export {};

package/lib/types/router/PathWithParams.d.ts

@@ -0,0 +1,8 @@
+export declare class PathWithParams {
+    path: string;
+    params: URLSearchParams;
+    hash: string;
+    constructor(path: string);
+    add(params: Record<string, string>): this;
+    toString(): string;
+}

package/lib/types/router/Route404.d.ts

@@ -0,0 +1,3 @@
+import { RouteMatch } from "./Router";
+export declare function Route404Component(): import("react/jsx-runtime").JSX.Element;
+export declare function createRoute404(): RouteMatch;

package/lib/types/router/RouteComponent.d.ts

@@ -0,0 +1,5 @@
+interface RouteComponentProps {
+    spinner?: React.ReactNode;
+}
+export declare function RouteComponent({ spinner }: RouteComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/router/Router.d.ts

@@ -0,0 +1,73 @@
+import { HistoryNavigator, LocationChangeEvent, NavigateOptions } from "./HistoryNavigator";
+import { PathMatch, PathMatcher } from "./PathMatcher";
+export type LazyImportFn = () => Promise<any>;
+export interface ComponentRoute {
+    path: string;
+    Component: React.ComponentType<any>;
+}
+export interface LazyComponentRoute {
+    path: string;
+    LazyComponent: LazyImportFn;
+}
+export type Route = ComponentRoute | LazyComponentRoute;
+export interface RouteMatch extends PathMatch<Route> {
+    state: any;
+}
+export interface NavigationPrompt {
+    message: string;
+    when?: boolean;
+}
+export declare abstract class BaseRouter {
+    index?: string;
+    matcher: PathMatcher<Route>;
+    constructor(routes: Route[], index?: string);
+    abstract getTopRouter(): Router;
+    match(path: string): PathMatch<Route> | null;
+    abstract navigate(path: string, options?: NavigateOptions): void;
+}
+export declare class Router extends BaseRouter {
+    prompt?: NavigationPrompt;
+    observer?: (event: LocationChangeEvent) => void;
+    navigator: HistoryNavigator;
+    constructor(routes: Route[], updateState: (route: RouteMatch | null) => void);
+    getTopRouter(): Router;
+    /**
+     * Subsequent navigations will preserve the given params in the query string.
+     * Use null to clear the sticky params.
+     * @param params
+     */
+    setStickyParams(params: Record<string, string> | null): void;
+    withObserver(observer?: ((event: LocationChangeEvent) => void) | undefined): this;
+    start(): void;
+    stop(): void;
+    navigate(path: string, options?: NavigateOptions): void;
+}
+export declare class NestedRouter extends BaseRouter {
+    parent: BaseRouter;
+    basePath: string;
+    constructor(parent: BaseRouter, basePath: string, routes: Route[]);
+    getTopRouter(): Router;
+    navigate(path: string, options?: NavigateOptions | undefined): void;
+}
+export interface RouterContext {
+    location: Location;
+    route: Route;
+    router: BaseRouter;
+    params: Record<string, string>;
+    state: any;
+    /**
+     * The path that matched the route. For wildcard `/*` paths this does not include the wildcard part.
+     * You can get the wildcard path from `remainingPath`.
+     */
+    matchedRoutePath: string;
+    remainingPath?: string;
+    navigate: (path: string, options?: NavigateOptions) => void;
+}
+declare const ReactRouterContext: import("react").Context<RouterContext | undefined>;
+export { ReactRouterContext };
+export declare function useRouterContext(): RouterContext;
+export declare function useNavigate(): (path: string, options?: NavigateOptions) => void;
+type UseParamsReturn<T> = T extends string ? string : Record<string, string>;
+export declare function useParams<T>(arg?: T): UseParamsReturn<T>;
+export declare function useLocation(): Location;
+export declare function useNavigationPrompt(prompt: NavigationPrompt): void;

package/lib/types/router/RouterProvider.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { Route } from "./Router";
+import { LocationChangeEvent } from "./HistoryNavigator";
+interface RouterProviderProps {
+    routes: Route[];
+    /**
+     * The path to use for the root resource. Defaults to '/'. Cannot contains path variables or wildcards
+     */
+    index?: string;
+    children?: React.ReactNode;
+    onChange?: (event: LocationChangeEvent) => void;
+}
+export declare function RouterProvider({ routes, index, onChange, children }: RouterProviderProps): import("react/jsx-runtime").JSX.Element | undefined;
+export {};

package/lib/types/router/index.d.ts

@@ -1,4 +1,10 @@
-export interface Route {
-    xxx: boolean;
-}
-export declare function xxx(): void;
+export * from "./FixLinks.js";
+export * from "./HistoryNavigator.js";
+export * from "./Nav.js";
+export * from "./NestedNavigationContext.js";
+export * from "./NestedRouterProvider.js";
+export * as Path from "./path.js";
+export * from "./PathMatcher.js";
+export * from "./RouteComponent.js";
+export * from "./Router.js";
+export * from "./RouterProvider.js";

package/lib/types/router/path.d.ts

@@ -0,0 +1,7 @@
+export type PathMatchParams = Record<string, string> & {
+    _?: string[];
+};
+export declare function isRootPath(path: string): path is "" | "/";
+export declare function joinPath(path1: string, path2: string): string;
+export declare function getPathSegments(path: string): string[];
+export declare function toSegments(path: string | string[]): string[];

package/lib/types/session/TypeRegistry.d.ts

@@ -0,0 +1,9 @@
+import { ContentObjectTypeItem } from "@vertesia/common";
+export declare class TypeRegistry {
+    types: ContentObjectTypeItem[];
+    map: Record<string, ContentObjectTypeItem>;
+    constructor(types: ContentObjectTypeItem[]);
+    getType(id: string): ContentObjectTypeItem;
+    getTypeLayout(id: string): import("@vertesia/common").ColumnLayout[] | undefined;
+    getTypeName(id: string): string | undefined;
+}

package/lib/types/session/UserSession.d.ts

@@ -0,0 +1,39 @@
+import { VertesiaClient } from '@vertesia/client';
+import { AuthTokenPayload } from '@vertesia/common';
+import { TypeRegistry } from './TypeRegistry';
+export declare const LastSelectedAccountId_KEY = "composableai.lastSelectedAccountId";
+export declare const LastSelectedProjectId_KEY = "composableai.lastSelectedProjectId";
+declare class UserSession {
+    isLoading: boolean;
+    client: VertesiaClient;
+    authError?: Error;
+    authToken?: AuthTokenPayload;
+    typeRegistry?: TypeRegistry;
+    setSession?: (session: UserSession) => void;
+    lastSelectedAccount?: string | null;
+    lastSelectedProject?: string | null;
+    onboardingComplete?: boolean;
+    constructor(client?: VertesiaClient, setSession?: (session: UserSession) => void);
+    get store(): import("@vertesia/client").ZenoClient;
+    get user(): AuthTokenPayload | undefined;
+    get account(): import("@vertesia/common").AccountRef | undefined;
+    get project(): import("@vertesia/common").ProjectRef | undefined;
+    get accounts(): import("@vertesia/common").AccountRef[] | undefined;
+    get authCallback(): Promise<string>;
+    get rawAuthToken(): Promise<string>;
+    signOut(): void;
+    getAccount(): import("@vertesia/common").AccountRef | undefined;
+    login(token: string): Promise<void>;
+    isLoggedIn(): boolean;
+    logout(): void;
+    switchAccount(targetAccountId: string): Promise<void>;
+    switchProject(targetProjectId: string): Promise<void>;
+    _loadTypes(): Promise<TypeRegistry | undefined>;
+    reloadTypes(): Promise<void>;
+    fetchAccounts(): Promise<void>;
+    fetchOnboardingStatus(): Promise<boolean>;
+    clone(): UserSession;
+}
+declare const UserSessionContext: import("react").Context<UserSession>;
+export declare function useUserSession(): UserSession;
+export { UserSession, UserSessionContext };

package/lib/types/session/UserSessionProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+interface UserSessionProviderProps {
+    children: ReactNode | ReactNode[];
+}
+export declare function UserSessionProvider({ children }: UserSessionProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/session/auth/composable.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Handle client caching and refresh of auth token
+ */
+import { AuthTokenPayload } from "@vertesia/common";
+interface ComposableTokenResponse {
+    rawToken: string;
+    token: AuthTokenPayload;
+    error: boolean;
+    message?: string;
+}
+export declare function fetchComposableToken(getIdToken: () => Promise<string | null | undefined>, accountId?: string, projectId?: string, ttl?: number): Promise<string>;
+/**
+ *
+ * @param accountId
+ * @param projectId
+ * @param ttl time to live for the token in seconds
+ * @returns
+ */
+export declare function fetchComposableTokenFromFirebaseToken(accountId?: string, projectId?: string, ttl?: number): Promise<string>;
+export declare function getComposableToken(accountId?: string, projectId?: string, initToken?: string, forceRefresh?: boolean): Promise<ComposableTokenResponse>;
+export declare class UserNotFoundError extends Error {
+    email: string;
+    constructor(message: string, email: string);
+}
+export {};

package/lib/types/session/auth/firebase.d.ts

@@ -0,0 +1,9 @@
+import { UIResolvedTenant } from "@vertesia/common";
+import { Analytics } from "firebase/analytics";
+import { FirebaseApp } from "firebase/app";
+import { Auth } from "firebase/auth";
+export declare function getFirebaseApp(): FirebaseApp;
+export declare function getFirebaseAnalytics(): Analytics;
+export declare function getFirebaseAuth(): Auth;
+export declare function setFirebaseTenant(tenantEmail?: string): Promise<UIResolvedTenant | undefined>;
+export declare function getFirebaseAuthToken(refresh?: boolean): Promise<string | null>;

package/lib/types/session/auth/useAuthState.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This hook is used to generate and verify state for OAuth2 authorization requests.
+ * @returns
+ */
+export declare function useAuthState(): {
+    generateState: () => `${string}-${string}-${string}-${string}-${string}`;
+    verifyState: (returnedState: string | null) => string | undefined;
+    clearState: () => void;
+};

package/lib/types/session/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./auth/composable";
+export * from "./auth/firebase";
+export * from "./TypeRegistry";
+export * from "./UserSession";
+export * from "./UserSessionProvider";
+export * from "./useUXTracking";

package/lib/types/session/useUXTracking.d.ts

@@ -0,0 +1,5 @@
+import { AuthTokenPayload } from '@vertesia/common';
+export declare function useUXTracking(): {
+    tagUserSession: (user?: AuthTokenPayload) => Promise<void>;
+    trackEvent: (eventName: string, eventProperties?: any) => void;
+};

package/lib/types/widgets/codemirror/CodeMirrorEditor.d.ts

@@ -0,0 +1,22 @@
+import { RefObject } from 'react';
+import { Extension, Text } from '@codemirror/state';
+import { EditorView, ViewUpdate } from '@codemirror/view';
+export declare class EditorApi {
+    editor: EditorView;
+    constructor(editor: EditorView);
+    setValue(value?: string): void;
+    getValue(): string;
+}
+interface CodeMirrorEditorProps {
+    value?: string | Text;
+    className?: string;
+    editorRef?: RefObject<EditorApi | undefined>;
+    extensions: Extension;
+    onChange?: (update: ViewUpdate) => void;
+    debounceTimeout?: number;
+}
+/**
+ * The className is only used on the first rendering - the editor class will not be updated if the property changes
+**/
+export declare function CodeMirrorEditor({ onChange, value, className, editorRef, extensions, debounceTimeout }: CodeMirrorEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/widgets/codemirror/CodemirrorStateSingleton.d.ts

@@ -0,0 +1,14 @@
+import { EditorState, Text } from '@codemirror/state';
+/**
+ * Returns a shared instance of CodeMirror's EditorState.
+ * If the instance doesn't exist, it creates one with the given initial content.
+ *
+ * @param initialDoc - The initial content for the editor, either as a `string` or `Text`.
+ * @param extensions - Optional extensions to be applied to the editor.
+ * @returns The shared EditorState instance.
+**/
+export declare const getSharedEditorState: (initialDoc?: string | Text, extensions?: any[]) => EditorState;
+/**
+ * Resets the singleton instance (useful for testing or reinitializing).
+**/
+export declare const resetSharedEditorState: () => void;

package/lib/types/widgets/codemirror/index.d.ts

@@ -0,0 +1 @@
+export * from "./CodeMirrorEditor.js";

package/lib/types/widgets/form/Form.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchemaObject } from "@vertesia/common";
+import { ComponentType, ReactNode } from "react";
+import { InputComponentProps } from "./FormContext.js";
+import { ManagedObject, ManagedProperty, Node } from "./ManagedObject.js";
+interface FormProps {
+    object: ManagedObject;
+    components?: Record<string, ComponentType<InputComponentProps>>;
+    children?: ReactNode | ReactNode[];
+    onSubmit?: (data: JSONSchemaObject) => void;
+    onChange?: (prop: Node) => void;
+}
+export declare function Form({ object, components, onSubmit, children, onChange }: FormProps): import("react/jsx-runtime").JSX.Element;
+export declare function GeneratedForm({ children, ...props }: FormProps): import("react/jsx-runtime").JSX.Element;
+interface ScalarFieldProps {
+    object: ManagedProperty;
+    inline?: boolean;
+    editor?: string;
+}
+export declare function ScalarField({ object, editor, inline }: ScalarFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/widgets/form/FormContext.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from "react";
+import { ManagedObject, ManagedObjectBase, Node } from "./ManagedObject.js";
+declare const FieldSetContextProvider: import("react").Provider<ManagedObjectBase<import("./schema.js").Schema> | undefined>;
+export declare function useFieldSet(): ManagedObjectBase<import("./schema.js").Schema>;
+export interface InputComponentProps {
+    object: Node;
+    type: string;
+}
+declare class FormContext {
+    object: ManagedObject;
+    components: Record<string, ComponentType<InputComponentProps>>;
+    constructor(object: ManagedObject, components?: Record<string, ComponentType<InputComponentProps>>);
+}
+export declare function useForm(): FormContext;
+declare const FormContextProvider: import("react").Provider<FormContext | undefined>;
+export { FieldSetContextProvider, FormContextProvider };

package/lib/types/widgets/form/ManagedObject.d.ts

@@ -0,0 +1,81 @@
+import type { JSONSchema, JSONSchemaArray, JSONSchemaObject, JSONSchemaType } from "@vertesia/common";
+import { ArrayPropertySchema, PropertySchema, Schema } from "./schema.js";
+export declare function computeTitleFromName(name: string): string;
+export declare abstract class Node<SchemaT extends Schema = Schema, ValueT = JSONSchemaType> {
+    parent: Node | null;
+    schema: SchemaT;
+    name: string;
+    observer?: (node: Node) => void | false;
+    abstract value: ValueT;
+    constructor(parent: Node | null, schema: SchemaT, name: string);
+    get isRoot(): boolean;
+    get root(): Node;
+    get path(): string[];
+    get isScalar(): boolean;
+    get isListItem(): boolean;
+    get isObject(): boolean;
+    get isList(): boolean;
+    get title(): any;
+    protected onChange(node: Node): void;
+}
+export declare abstract class ManagedObjectBase<SchemaT extends Schema = Schema> extends Node<SchemaT, JSONSchemaObject> {
+    abstract value: JSONSchemaObject;
+    constructor(parent: Node | null, schema: SchemaT, name: string);
+    get isObject(): boolean;
+    getProperty(name: string): ManagedListProperty | ManagedObjectProperty | ManagedProperty;
+    getOrInitObjectProperty(name: string): JSONSchemaObject;
+    getOrInitArrayProperty(name: string): JSONSchemaArray;
+    setPropertyValue(name: string, value: JSONSchemaType): boolean;
+    getPropertyValue(name: string): JSONSchemaType;
+    get properties(): Node[];
+    [Symbol.iterator](): ArrayIterator<Node<Schema, JSONSchemaType>>;
+}
+export declare class ManagedObject extends ManagedObjectBase<Schema> {
+    value: JSONSchemaObject;
+    constructor(schema: Schema | JSONSchema, value?: JSONSchemaObject);
+}
+export declare class ManagedObjectProperty extends ManagedObjectBase<PropertySchema> {
+    value: JSONSchemaObject;
+    constructor(parent: Node, schema: PropertySchema, name: string, value: JSONSchemaObject);
+}
+export declare class ManagedProperty extends Node<PropertySchema> {
+    constructor(parent: ManagedObjectBase, schema: PropertySchema);
+    get isScalar(): boolean;
+    set value(value: JSONSchemaType);
+    get value(): JSONSchemaType;
+    getInputType(): any;
+}
+export declare class ManagedListProperty extends Node<ArrayPropertySchema, JSONSchemaArray> {
+    value: JSONSchemaArray;
+    items: MangedListItem[];
+    constructor(parent: ManagedObjectBase, schema: ArrayPropertySchema, value: JSONSchemaArray);
+    get isList(): boolean;
+    newItem(index: number): ManagedScalarEntry | ManageObjectEntry;
+    add(): ManagedScalarEntry | ManageObjectEntry;
+    remove(index: number): void;
+    [Symbol.iterator](): ArrayIterator<MangedListItem>;
+    item(index: number): ManagedObjectProperty | ManagedScalarEntry | undefined;
+    /**
+     * remove undefined items from the end of the list if any
+     */
+    trim(): void;
+}
+export declare class ManageObjectEntry extends ManagedObjectBase {
+    index: number;
+    key: string;
+    constructor(parent: ManagedListProperty, index: number);
+    get isListItem(): boolean;
+    set value(value: JSONSchemaObject);
+    get value(): JSONSchemaObject;
+}
+export declare class ManagedScalarEntry extends Node<ArrayPropertySchema> {
+    index: number;
+    key: string;
+    constructor(parent: ManagedListProperty, index: number);
+    get isScalar(): boolean;
+    get isListItem(): boolean;
+    set value(value: JSONSchemaType);
+    get value(): JSONSchemaType;
+    getInputType(): any;
+}
+export type MangedListItem = ManagedScalarEntry | ManageObjectEntry;

package/lib/types/widgets/form/fields.d.ts

@@ -0,0 +1,15 @@
+interface FormLabelProps {
+    htmlFor?: string;
+    required?: boolean;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function FormLabel({ htmlFor, required, children }: FormLabelProps): import("react/jsx-runtime").JSX.Element;
+interface FormHelperProps {
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function FormHelper({ children }: FormHelperProps): import("react/jsx-runtime").JSX.Element;
+interface FormErrorProps {
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function FormError({ children }: FormErrorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/widgets/form/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Form.js";
+export * from "./FormContext.js";
+export * from "./ManagedObject.js";
+export * from "./fields.js";
+export * from "./inputs.js";
+export * from "./schema.js";

package/lib/types/widgets/form/inputs.d.ts

@@ -0,0 +1,7 @@
+import React, { InputHTMLAttributes } from "react";
+import { ManagedProperty } from "./ManagedObject.js";
+interface InputProps extends InputHTMLAttributes<HTMLInputElement | HTMLTextAreaElement> {
+    object: ManagedProperty;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement | HTMLTextAreaElement>>;
+export { Input };

package/lib/types/widgets/form/schema.d.ts

@@ -0,0 +1,45 @@
+import { JSONSchema, JSONSchemaType, JSONSchemaTypeName } from "@vertesia/common";
+import { ValidateFunction } from "ajv";
+export declare class Schema {
+    schema: JSONSchema;
+    properties: Record<string, PropertySchema>;
+    validator: ValidateFunction;
+    constructor(schema?: JSONSchema);
+    private load;
+    hasProperties(): boolean;
+    get title(): any;
+    get description(): string | undefined;
+    private loadProperty;
+    get type(): JSONSchemaTypeName;
+    validate(value: any): true | import("ajv").ErrorObject<string, Record<string, any>, unknown>[];
+    addProperty(name: string, typeOrSchema: JSONSchemaTypeName | JSONSchema, isRequired?: boolean): PropertySchema;
+    removeProperty(name: string): void;
+    getProperty(name: string): PropertySchema;
+    get editor(): any;
+}
+export declare class PropertySchema extends Schema {
+    parent: Schema;
+    name: string;
+    constructor(parent: Schema, name: string, schema: JSONSchema);
+    get isMulti(): boolean;
+    get isReadOnly(): boolean;
+    set isReadOnly(value: boolean);
+    get defaultValue(): JSONSchemaType | undefined;
+    set defaultValue(value: JSONSchemaType | undefined);
+    get enum(): JSONSchemaType[] | undefined;
+    set enum(values: JSONSchemaType[] | undefined);
+    get isRequired(): boolean;
+    set isRequired(value: boolean);
+    get type(): JSONSchemaTypeName;
+    set type(value: JSONSchemaTypeName);
+    remove(): void;
+    get isBoolean(): boolean;
+    get isString(): boolean;
+    get isNumber(): boolean;
+    get isObject(): boolean;
+}
+export declare class ArrayPropertySchema extends PropertySchema {
+    arraySchema: JSONSchema;
+    constructor(parent: Schema, name: string, schema: JSONSchema);
+    get isMulti(): boolean;
+}

package/lib/types/widgets/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./xml-viewer/index.js";
+export * from "./json-view/index.js";
+export * from "./schema-editor/index.js";
+export * from "./form/index.js";
+export * from "./codemirror/index.js";

package/lib/types/widgets/json-view/JSONCode.d.ts

@@ -0,0 +1,21 @@
+interface JsonCodeClassMap {
+    code: string;
+    comma: string;
+    assign: string;
+    startObject: string;
+    endObject: string;
+    startArray: string;
+    endArray: string;
+    boolean: string;
+    null: string;
+    key: string;
+    index: string;
+    string: string;
+    number: string;
+}
+export declare function JSONCode({ data, className, classMap }: {
+    data: any;
+    className?: string;
+    classMap?: JsonCodeClassMap;
+}): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | undefined;
+export {};

package/lib/types/widgets/json-view/JSONDisplay.d.ts

@@ -0,0 +1,7 @@
+import type { JSONObject } from "@vertesia/json";
+interface JSONDisplayProps {
+    value: JSONObject;
+    viewCode?: boolean;
+}
+export declare function JSONDisplay({ value, viewCode }: JSONDisplayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/widgets/json-view/JSONView.d.ts

@@ -0,0 +1,6 @@
+import type { JSONObject } from "@vertesia/json";
+interface JSONViewProps {
+    value: JSONObject;
+}
+export declare function JSONView({ value }: JSONViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/widgets/json-view/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./types.js";
+export * from "./JSONCode.js";
+export * from "./JSONDisplay.js";
+export * from "./JSONView.js";

package/lib/types/widgets/json-view/types.d.ts

@@ -0,0 +1,7 @@
+export type JSONPrimitive = string | number | boolean | null;
+export type JSONArray = JSONValue[];
+export type JSONObject = {
+    [key: string]: JSONValue;
+};
+export type JSONComposite = JSONArray | JSONObject;
+export type JSONValue = JSONPrimitive | JSONComposite;

package/lib/types/widgets/schema-editor/JSONSchemaEditorModal.d.ts

@@ -0,0 +1,9 @@
+import { ManagedSchema } from "./ManagedSchema.js";
+interface JSONSchemaEditorModalProps {
+    schema: ManagedSchema;
+    isOpen?: boolean;
+    onClose: () => void;
+    readonly?: boolean;
+}
+export declare function JSONSchemaEditorModal({ schema, isOpen, onClose, readonly }: JSONSchemaEditorModalProps): import("react/jsx-runtime").JSX.Element;
+export {};