@vertesia/ui 0.59.0 → 0.61.0

package/lib/types/features/store/objects/search/DocumentSearchContext.d.ts

@@ -0,0 +1,48 @@
+import { SharedState } from '@vertesia/ui/core';
+import { ComputeFacetsResponse, ZenoClient } from '@vertesia/client';
+import { ComplexSearchQuery, ContentObjectItem, FacetBucket, FacetSpec, ObjectSearchQuery } from '@vertesia/common';
+interface DocumentSearchResult {
+    objects: ContentObjectItem[];
+    error?: Error;
+    isLoading: boolean;
+}
+export declare class DocumentSearch {
+    client: ZenoClient;
+    limit: number;
+    collectionId?: string;
+    facets: SharedState<ComputeFacetsResponse>;
+    result: SharedState<DocumentSearchResult>;
+    facetSpecs: FacetSpec[];
+    query: ComplexSearchQuery;
+    constructor(client: ZenoClient, limit?: number);
+    withFacets(facets: FacetSpec[]): this;
+    get objects(): ContentObjectItem<Record<string, any>>[];
+    get error(): Error | undefined;
+    get isRunning(): boolean;
+    getFilterValue(name: string): any;
+    setFilterValue(name: string, value: any): void;
+    clearFilters(): void;
+    getFacetBuckets(name: string): FacetBucket[];
+    resetFacets(): void;
+    reset(isLoading?: boolean): void;
+    _updateRunningState(value: boolean): void;
+    _searchRequest(query: ComplexSearchQuery, limit: number, offset: number): Promise<ContentObjectItem<Record<string, any>>[]>;
+    _facetsRequest(): Promise<ComputeFacetsResponse>;
+    computeFacets(_query: ObjectSearchQuery): void;
+    _search(loadMore?: boolean): Promise<boolean>;
+    search(noFacets?: boolean): Promise<boolean>;
+    loadMore(noFacets?: boolean): Promise<boolean>;
+}
+declare const DocumentSearchContext: import("react").Context<DocumentSearch | undefined>;
+export declare function useDocumentSearch(): DocumentSearch;
+export declare function useWatchDocumentSearchFacets(): ComputeFacetsResponse;
+export declare function useWatchDocumentSearchResult(): {
+    search: DocumentSearch;
+    objects: ContentObjectItem[];
+    error?: Error;
+    isLoading: boolean;
+};
+export declare function useDocumentSearchCount(): {
+    count: number;
+}[] | undefined;
+export { DocumentSearchContext as SearchContext };

package/lib/types/features/store/objects/search/DocumentSearchProvider.d.ts

@@ -0,0 +1,15 @@
+import { FacetSpec, SupportedEmbeddingTypes } from "@vertesia/common";
+import React from "react";
+interface DocumentSearchProviderProps {
+    children: React.ReactNode;
+    limit?: number;
+    typeId?: string;
+    parent?: string;
+    facets?: FacetSpec[];
+    similarTo?: string;
+    embeddingType?: SupportedEmbeddingTypes;
+    collectionId?: string;
+    name?: string;
+}
+export declare function DocumentSearchProvider({ children, limit, parent, typeId, facets, similarTo, embeddingType, name, collectionId }: DocumentSearchProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/objects/search/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DocumentSearchContext";
+export * from "./DocumentSearchProvider";

package/lib/types/features/store/objects/selection/ObjectsActionContext.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { ObjectsActionParams, ObjectsActionSpec } from './ObjectsActionSpec';
+export type ObjectsActionCallback = (params: ObjectsActionParams) => Promise<unknown>;
+export declare class ObjectsActionContext {
+    params: Omit<ObjectsActionParams, 'action'>;
+    allActions: ObjectsActionSpec[];
+    wfRules: ObjectsActionSpec[];
+    callbacks: Record<string, ObjectsActionCallback>;
+    startWorkflow?: ObjectsActionCallback;
+    constructor(params: Omit<ObjectsActionParams, 'action'>);
+    get actions(): ObjectsActionSpec[];
+    loadWorkflows(): Promise<ObjectsActionSpec[]>;
+    registerCallback(name: string, cb: (params: ObjectsActionParams) => Promise<unknown>): () => void;
+    unregisterCallback(name: string): void;
+    findAction(actionId: string): ObjectsActionSpec | undefined;
+    run(actionId: string): Promise<unknown>;
+}
+interface ObjectsActionContextProps {
+    children: ReactNode;
+}
+export declare function ObjectsActionContextProvider({ children }: ObjectsActionContextProps): import("react/jsx-runtime").JSX.Element;
+export declare function useObjectsActionContext(): ObjectsActionContext;
+export declare function useObjectsActionCallback(name: string, cb: ObjectsActionCallback): ObjectsActionContext;
+export declare function useStartWorkflowCallback(cb: ObjectsActionCallback): ObjectsActionContext;
+export {};

package/lib/types/features/store/objects/selection/ObjectsActionSpec.d.ts

@@ -0,0 +1,27 @@
+import { VertesiaClient } from "@vertesia/client";
+import { ToastFn } from "@vertesia/ui/core";
+import { DocumentSearch, DocumentSelection } from "../../../store";
+export interface ObjectsActionSpec {
+    id: string;
+    name: string;
+    description?: string;
+    confirm?: boolean;
+    confirmationText?: string;
+    component: ActionComponentType;
+    hideInList?: boolean;
+    destructive?: boolean;
+}
+export interface ObjectsActionParams {
+    action: ObjectsActionSpec;
+    client: VertesiaClient;
+    selection: DocumentSelection;
+    toast: ToastFn;
+    search: DocumentSearch;
+}
+export interface ActionComponentTypeProps {
+    action: ObjectsActionSpec;
+    objectIds: string[];
+    children?: React.ReactNode;
+    collectionId?: string;
+}
+export type ActionComponentType = React.ComponentType<ActionComponentTypeProps>;

package/lib/types/features/store/objects/selection/SelectionActions.d.ts

@@ -0,0 +1,4 @@
+export declare function SelectionActions(): import("react/jsx-runtime").JSX.Element;
+export declare function UploadObjectsButton({ collectionId }: {
+    collectionId?: string;
+}): false | import("react/jsx-runtime").JSX.Element;

package/lib/types/features/store/objects/selection/actions/AddToCollectionAction.d.ts

@@ -0,0 +1,3 @@
+import { ActionComponentTypeProps, ObjectsActionSpec } from "../ObjectsActionSpec";
+export declare function AddToCollectionActionComponent({ action, objectIds }: ActionComponentTypeProps): false | import("react/jsx-runtime").JSX.Element;
+export declare const AddToCollectionAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/ChangeTypeAction.d.ts

@@ -0,0 +1,3 @@
+import { ActionComponentTypeProps, ObjectsActionSpec } from "../ObjectsActionSpec";
+export declare function ChangeTypeActionComponent({ action, objectIds, children }: ActionComponentTypeProps): import("react/jsx-runtime").JSX.Element;
+export declare const ChangeTypeAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/ConfirmAction.d.ts

@@ -0,0 +1,15 @@
+import { ObjectsActionCallback } from "../ObjectsActionContext";
+import { ObjectsActionSpec } from "../ObjectsActionSpec";
+interface ObjectsActionComponentProps {
+    action: ObjectsActionSpec;
+    callback: ObjectsActionCallback;
+    children?: React.ReactNode;
+}
+/**
+ * Generic implementation of an action component.
+ * The action component is not the one which is clicked by the user, but the one that is registering the action callback.
+ * @param param0
+ * @returns
+ */
+export default function ConfirmAction({ action, callback, children }: ObjectsActionComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/objects/selection/actions/DeleteObjectsAction.d.ts

@@ -0,0 +1,2 @@
+import { ObjectsActionSpec } from '../ObjectsActionSpec';
+export declare const DeleteObjectsAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/ExportPropertiesAction.d.ts

@@ -0,0 +1,3 @@
+import { ActionComponentTypeProps, ObjectsActionSpec } from "../ObjectsActionSpec";
+export declare function ExportPropertiesComponent({ action, objectIds }: ActionComponentTypeProps): import("react/jsx-runtime").JSX.Element;
+export declare const ExportPropertiesAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/RemoveFromCollectionAction.d.ts

@@ -0,0 +1,2 @@
+import { ObjectsActionSpec } from '../ObjectsActionSpec';
+export declare const RemoveFromCollectionAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/StartWorkflowComponent.d.ts

@@ -0,0 +1,3 @@
+import { ActionComponentTypeProps, ObjectsActionSpec } from "../ObjectsActionSpec";
+export declare function StartWorkflowComponent({ action, objectIds, collectionId }: ActionComponentTypeProps): import("react/jsx-runtime").JSX.Element;
+export declare const StartWorkflowAction: ObjectsActionSpec;

package/lib/types/features/store/objects/selection/actions/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AddToCollectionAction";
+export * from "./ChangeTypeAction";
+export * from "./ConfirmAction";
+export * from "./DeleteObjectsAction";
+export * from "./ExportPropertiesAction";
+export * from "./RemoveFromCollectionAction";
+export * from "./StartWorkflowComponent";

package/lib/types/features/store/objects/selection/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./actions";
+export * from "./ObjectsActionContext";
+export * from "./ObjectsActionSpec";
+export * from "./SelectionActions";

package/lib/types/features/store/objects/upload/DocumentUploadModal.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from "react";
+import { DocumentUploadResult } from "./useUploadHandler";
+/**
+ * Props for the unified UploadModal component
+ */
+interface DocumentUploadModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback when the modal is closed */
+    onClose: () => void;
+    /** Optional initial files to upload */
+    files?: File[];
+    /** Collection ID to upload to */
+    collectionId?: string;
+    /** Selected folder for uploaded files */
+    selectedFolder?: string | null;
+    /** Title for the modal */
+    title?: string;
+    /** Children to render in the modal */
+    children?: ReactNode;
+    /** Callback when upload is complete */
+    onUploadComplete?: (result: DocumentUploadResult) => void;
+    /** Hide the file selection step and proceed directly to type selection */
+    hideFileSelection?: boolean;
+    /** Show only the type selection, used for type change operations */
+    showTypeSelectionOnly?: boolean;
+}
+/**
+ * Unified upload modal that handles the complete upload process:
+ * 1. File selection (if no files provided)
+ * 2. Smart file processing to detect duplicates
+ * 3. Type selection
+ * 4. Upload with progress tracking
+ * 5. Result display
+ */
+export declare function DocumentUploadModal({ isOpen, onClose, files: initialFiles, collectionId, selectedFolder, title, children, onUploadComplete, hideFileSelection, showTypeSelectionOnly, }: DocumentUploadModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/objects/upload/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DocumentUploadModal";
+export * from "./useSmartFileUploadProcessing";
+export * from "./useUploadHandler";

package/lib/types/features/store/objects/upload/useSmartFileUploadProcessing.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Types of actions that can be taken with a file
+ */
+export declare enum FileUploadAction {
+    CREATE = "create",// New document, not in system
+    SKIP = "skip",// Document exists, identical, no action needed
+    UPDATE = "update"
+}
+/**
+ * Interface for file metadata with hash information
+ */
+export interface FileWithMetadata {
+    file: File;
+    hash?: string;
+    name: string;
+    size: number;
+    location?: string;
+    existingId?: string;
+    action?: FileUploadAction;
+    metadata?: Record<string, any>;
+}
+/**
+ * Hook to check if documents need to be created, updated, or skipped
+ * @param collectionId Optional collection ID to check within
+ * @returns Object with functions to process documents
+ */
+export declare function useSmartFileUploadProcessing(): {
+    checkDocumentProcessing: (files: File[], selectedFolder?: string | null, limitToCollectionId?: string) => Promise<FileWithMetadata[]>;
+};

package/lib/types/features/store/objects/upload/useUploadHandler.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hook configuration for useUploadHandler
+ */
+export interface UploadHandlerOptions {
+    /**
+     * Callback to be called after upload is done with the created object IDs
+     */
+    onUploadDone: (objectIds: string[]) => Promise<void>;
+}
+/**
+ * Result of the upload process
+ */
+export interface DocumentUploadResult {
+    /** Whether the upload was successful overall */
+    success: boolean;
+    /** IDs of all processed objects (both newly uploaded and existing) */
+    objectIds: string[];
+    /** Newly uploaded files information */
+    uploadedFiles: UploadedFileInfo[];
+    /** Files that were skipped (already existed) */
+    skippedFiles: UploadedFileInfo[];
+    /** Files that failed to upload */
+    failedFiles: UploadedFileInfo[];
+}
+/**
+ * Information about a successfully uploaded file
+ */
+interface UploadedFileInfo {
+    /** The ID of the uploaded object */
+    id?: string;
+    /** The name of the file */
+    name: string;
+    /** The name of the file */
+    location?: string;
+    /** The status of the upload */
+    status: "created" | "updated" | "skipped" | "failed";
+    /** The type of the object */
+    type: string | null;
+    /** Has there been any Error */
+    error?: string;
+}
+/**
+ * Hook for handling file uploads to the store
+ *
+ * @param options Configuration options for the upload handler
+ * @returns Upload handler function that takes files and type, and returns upload results
+ */
+export declare function useDocumentUploadHandler(options: UploadHandlerOptions | ((objectIds: string[]) => Promise<void>)): (files: File[], type: string | null, collectionId?: string) => Promise<DocumentUploadResult>;
+export {};

package/lib/types/features/store/types/ContentObjectTypeView.d.ts

@@ -0,0 +1,5 @@
+interface ContentObjectTypeViewProps {
+    typeId: string;
+}
+export declare function ContentObjectTypeView({ typeId }: ContentObjectTypeViewProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/store/types/ContentObjectTypesSearch.d.ts

@@ -0,0 +1,5 @@
+interface ContentObjectTypesSearchProps {
+    isDirty?: boolean;
+}
+export declare function ContentObjectTypesSearch({ isDirty }: ContentObjectTypesSearchProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/ContentObjectTypesTable.d.ts

@@ -0,0 +1,7 @@
+import { ContentObjectTypeItem } from "@vertesia/common";
+interface ContentObjectTypesTableProps {
+    objects?: ContentObjectTypeItem[];
+    isLoading: boolean;
+}
+export declare function ContentObjectTypesTable({ objects, isLoading }: ContentObjectTypesTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/ContentObjectTypesView.d.ts

@@ -0,0 +1,8 @@
+export declare enum ChunkableOptions {
+    true = "Yes",
+    false = "No"
+}
+interface ContentObjectTypesViewProps {
+}
+export declare function ContentObjectTypesView({}: ContentObjectTypesViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/CreateOrUpdateTypeModal.d.ts

@@ -0,0 +1,14 @@
+export interface CreateOrUpdateTypePayload {
+    name: string;
+    description?: string;
+    strict_mode?: boolean;
+}
+interface CreateOrUpdateTypeModalProps {
+    title: string;
+    isOpen: boolean;
+    onClose: (payload?: CreateOrUpdateTypePayload) => Promise<unknown>;
+    okLabel: string;
+    initialPayload?: CreateOrUpdateTypePayload;
+}
+export declare function CreateOrUpdateTypeModal({ title, isOpen, onClose, okLabel, initialPayload }: CreateOrUpdateTypeModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/ObjectSchemaEditor.d.ts

@@ -0,0 +1,7 @@
+import { ContentObjectType } from '@vertesia/common';
+interface ObjectSchemaEditorProps {
+    objectType: ContentObjectType;
+    onSchemaUpdate: (jsonSchema: any) => void;
+}
+export declare function ObjectSchemaEditor({ objectType, onSchemaUpdate }: ObjectSchemaEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/SelectContentType.d.ts

@@ -0,0 +1,10 @@
+import { ContentObjectTypeItem } from "@vertesia/common";
+interface SelectContentTypeProps {
+    defaultValue?: string | string[] | null;
+    onChange: (type: ContentObjectTypeItem | null | ContentObjectTypeItem[]) => void;
+    className?: string;
+    isClearable?: boolean;
+    multiple?: boolean;
+}
+export declare function SelectContentType({ className, defaultValue, onChange, isClearable, multiple }: SelectContentTypeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/SelectContentTypeModal.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+import { ContentObjectTypeItem } from "@vertesia/common";
+/**
+ * Props for the SelectTypeModal component
+ */
+interface SelectContentTypeModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback when the modal is closed */
+    onClose: (typeId?: string | null | undefined) => void;
+    /** Title for the modal */
+    title?: string;
+    /** Children to render in the modal */
+    children?: ReactNode;
+    /** Optional initial selected type */
+    initialSelectedType?: ContentObjectTypeItem | null;
+    /** Optional description text */
+    description?: string;
+    /** Label for the confirm button */
+    confirmLabel?: string;
+    /** Whether to allow the "None" option */
+    allowNone?: boolean;
+}
+/**
+ * A dedicated modal for selecting content types.
+ *
+ * This is a lightweight modal specifically for selecting a content type,
+ * without any file upload functionality. Used for changing types, setting
+ * types in other contexts, etc.
+ */
+export declare function SelectContentTypeModal({ isOpen, onClose, title, children, initialSelectedType, confirmLabel, allowNone, }: SelectContentTypeModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/TableLayoutEditor.d.ts

@@ -0,0 +1,8 @@
+import { ColumnLayout, ContentObjectType } from '@vertesia/common';
+interface TableLayoutEditorProps {
+    objectType: ContentObjectType;
+    onLayoutUpdate: (value: ColumnLayout[] | undefined) => void;
+}
+export declare function TableLayoutEditor({ objectType, onLayoutUpdate }: TableLayoutEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function stringifyTableLayout(obj: any): string;
+export {};

package/lib/types/features/store/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./ContentObjectTypesSearch";
+export * from "./ContentObjectTypesTable";
+export * from "./ContentObjectTypesView";
+export * from "./ContentObjectTypeView";
+export * from "./CreateOrUpdateTypeModal";
+export * from "./ObjectSchemaEditor";
+export * from "./search";
+export * from "./SelectContentType";
+export * from "./SelectContentTypeModal";
+export * from "./TableLayoutEditor";

package/lib/types/features/store/types/search/ObjectTypeSearchContext.d.ts

@@ -0,0 +1,35 @@
+import { ContentObjectTypeItem, ObjectTypeSearchQuery } from "@vertesia/common";
+import { VertesiaClient, ZenoClient } from "@vertesia/client";
+import { SharedState } from "@vertesia/ui/core";
+interface ObjectTypeSearchResult {
+    objects: ContentObjectTypeItem[];
+    error?: Error;
+    isLoading: boolean;
+}
+export declare class ObjectTypeSearch {
+    client: VertesiaClient | ZenoClient;
+    limit: number;
+    result: SharedState<ObjectTypeSearchResult>;
+    query: ObjectTypeSearchQuery;
+    constructor(client: VertesiaClient | ZenoClient, limit?: number);
+    get objects(): ContentObjectTypeItem[];
+    get error(): Error | undefined;
+    get isRunning(): boolean;
+    getFilterValue(name: string): any;
+    setFilterValue(name: string, value: any): void;
+    reset(isLoading?: boolean): void;
+    _updateRunningState(value: boolean): void;
+    _search(loadMore?: boolean): Promise<boolean>;
+    search(): Promise<boolean>;
+    loadMore(): Promise<boolean>;
+}
+declare const ObjectTypeSearchContext: import("react").Context<ObjectTypeSearch | undefined>;
+export declare function useSearch(): ObjectTypeSearch;
+export declare function useWatchSearchResult(): {
+    search: ObjectTypeSearch;
+    objects: ContentObjectTypeItem[];
+    error?: Error;
+    isLoading: boolean;
+};
+export declare function useSearchCount(): number;
+export { ObjectTypeSearchContext };

package/lib/types/features/store/types/search/ObjectTypeSearchProvider.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface SearchProviderProps {
+    children: React.ReactNode;
+    limit?: number;
+    offset?: number;
+    name?: string;
+    chunkable?: boolean;
+}
+export declare function ObjectTypeSearchProvider({ children, limit, name, chunkable: chunkable }: SearchProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/store/types/search/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ObjectTypeSearchContext";
+export * from "./ObjectTypeSearchProvider";

package/lib/types/features/user/UserAvatar.d.ts

@@ -0,0 +1,8 @@
+import { AuthTokenPayload, UserRef } from "@vertesia/common";
+/**
+ * UserAvatar
+ * Show user picture, name and email
+ **/
+export declare function UserAvatar({ user }: {
+    user: AuthTokenPayload | UserRef;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/features/user/UserInfo.d.ts

@@ -0,0 +1,36 @@
+import { User } from "@vertesia/common";
+/**
+ * Fetch the user information given a user reference.
+ * The reference has the format: `type:id`. A special reference `system` is used to refer to the system user.
+ * @param userRef
+ */
+export declare function useFetchUserInfo(userId: string): {
+    data: User | undefined;
+    isLoading: boolean;
+    error: any;
+    setData: import("react").Dispatch<import("react").SetStateAction<User | undefined>>;
+    refetch: () => Promise<void>;
+};
+interface InfoProps {
+    showTitle?: boolean;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+}
+interface UserInfoProps extends InfoProps {
+    /**
+     * The user reference is a string that contains the type and id of the user.
+     *
+     * The format is: `type:id`, where "type" is the {@link PrincipalType} and the "id" is the
+     * object ID in the database.
+     *
+     * @example user:123
+     * @example service_account:123
+     * @example apikey:123
+     */
+    userRef: string | undefined;
+}
+export declare function UserInfo({ userRef, showTitle, size }: UserInfoProps): import("react/jsx-runtime").JSX.Element;
+interface ApiKeyAvatarProps extends InfoProps {
+    keyId: string;
+}
+export declare function ApiKeyAvatar({ keyId, showTitle, size }: ApiKeyAvatarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/user/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UserInfo";
+export * from "./UserAvatar";

package/lib/types/features/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./text.js";
+export * from "./mimeType.js";
+export * from "./rendition.js";

package/lib/types/features/utils/mimeType.d.ts

@@ -0,0 +1,4 @@
+export declare const isCsv: (type: string) => boolean;
+export declare const isImage: (type: string) => boolean;
+export declare const isPdf: (type: string) => boolean;
+export declare const isVideo: (type: string) => boolean;

package/lib/types/features/utils/rendition.d.ts

@@ -0,0 +1,3 @@
+import { VertesiaClient } from "@vertesia/client";
+import { ContentObjectItem } from "@vertesia/common";
+export declare function retrieveRendition(client: VertesiaClient, doc: ContentObjectItem, setRenditionUrl: (url: string) => void, setRenditionAlt: (alt: string) => void): Promise<string | undefined>;

package/lib/types/features/utils/text.d.ts

@@ -0,0 +1,2 @@
+export declare function shortId(id: string, length?: number): string;
+export declare function shortenString(str: string, length: number): string;

package/lib/types/layout/Sidebar.d.ts

@@ -24,6 +24,7 @@ export interface SidebarItemProps {
     tools?: React.ReactNode;
     className?: string;
     id?: string;
+    external?: boolean;
 }
-export declare function SidebarItem({ className, tools, children, icon: Icon, href, current, onClick }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarItem({ external, className, tools, children, icon: Icon, href, current, onClick }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,5 @@
+interface ProgressProps {
+    percent: number;
+}
+export declare function Progress({ percent }: ProgressProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,17 +1,18 @@
 import { JSONSchema, JSONSchemaType, JSONSchemaTypeName } from "@vertesia/common";
-import { ValidateFunction } from "ajv";
+import { ErrorObject, ValidateFunction } from "ajv";
 export declare class Schema {
     schema: JSONSchema;
     properties: Record<string, PropertySchema>;
-    validator: ValidateFunction;
+    _validator?: ValidateFunction;
     constructor(schema?: JSONSchema);
+    get validator(): ValidateFunction<unknown>;
     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>[];
+    validate(value: any): ErrorObject<string, Record<string, any>, unknown>[] | null;
     addProperty(name: string, typeOrSchema: JSONSchemaTypeName | JSONSchema, isRequired?: boolean): PropertySchema;
     removeProperty(name: string): void;
     getProperty(name: string): PropertySchema;

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

@@ -3,3 +3,7 @@ export * from "./json-view/index.js";
 export * from "./schema-editor/index.js";
 export * from "./form/index.js";
 export * from "./codemirror/index.js";
+export * from "./properties/index.js";
+export * from "./popover/index.js";
+export * from "./upload/index.js";
+export * from "./Progress.js";