dotvvm-types 3.0.2 → 4.1.0-preview04-final

package/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../../Resources/Scripts/typings/globalize/globalize.d.ts" />
 declare module "shared-classes" {
     export class DotvvmPostbackError {
         reason: DotvvmPostbackErrorReason;
@@ -25,9 +26,9 @@ declare module "utils/logging" {
     export function logPostBackScriptError(err: any): void;
 }
 declare module "serialization/date" {
-    export function parseDate(value: string): Date | null;
-    export function parseTimeSpan(value: string): number | null;
-    export function parseDateTimeOffset(value: string): Date | null;
+    export function parseDate(value: string | null, convertFromUtc?: boolean): Date | null;
+    export function parseTimeSpan(value: string | null): number | null;
+    export function parseDateTimeOffset(value: string | null): Date | null;
     export function serializeDate(date: string | Date | null, convertToUtc?: boolean): string | null;
     export function serializeTimeSpan(time: string | number | null): string | null;
 }
@@ -47,9 +48,13 @@ declare module "utils/knockout" {
 }
 declare module "utils/objects" {
     export function isPrimitive(viewModel: any): boolean;
-    export const createArray: <T>(a: ArrayLike<T>) => T[];
+    export const createArray: {
+        <T>(arrayLike: ArrayLike<T>): T[];
+        <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+        <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+        <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+    };
     export const hasOwnProperty: (obj: any, prop: string) => boolean;
-    export const symbolOrDollar: (name: string) => symbol;
     export const keys: {
         (o: object): string[];
         (o: {}): string[];
@@ -62,14 +67,6 @@ declare module "metadata/typeMap" {
     export function updateTypeInfo(newTypes: TypeMap | undefined): void;
     export function replaceTypeInfo(newTypes: TypeMap | undefined): void;
 }
-declare module "serialization/deserialize" {
-    export function deserialize(viewModel: any, target?: any, deserializeAll?: boolean): any;
-    export function deserializePrimitive(viewModel: any, target?: any): any;
-    export function deserializeDate(viewModel: any, target?: any): any;
-    export function deserializeArray(viewModel: any, target?: any, deserializeAll?: boolean): any;
-    export function deserializeObject(viewModel: any, target: any, deserializeAll: boolean): any;
-    export function extendToObservableArrayIfRequired(observable: any): any;
-}
 declare module "events" {
     export class DotvvmEvent<T> {
         readonly name: string;
@@ -94,7 +91,7 @@ declare module "events" {
     export const postbackCommitInvoked: DotvvmEvent<DotvvmPostbackCommitInvokedEventArgs>;
     export const postbackViewModelUpdated: DotvvmEvent<DotvvmPostbackViewModelUpdatedEventArgs>;
     export const postbackRejected: DotvvmEvent<DotvvmPostbackRejectedEventArgs>;
-    export const staticCommandMethodInvoking: DotvvmEvent<DotvvmStaticCommandMethodEventArgs>;
+    export const staticCommandMethodInvoking: DotvvmEvent<DotvvmStaticCommandMethodInvokingEventArgs>;
     export const staticCommandMethodInvoked: DotvvmEvent<DotvvmStaticCommandMethodInvokedEventArgs>;
     export const staticCommandMethodFailed: DotvvmEvent<DotvvmStaticCommandMethodFailedEventArgs>;
     export const newState: DotvvmEvent<RootViewModel>;
@@ -123,10 +120,57 @@ declare module "postback/updater" {
     export function patchViewModel(source: any, patch: any): any;
     export function diffViewModel(source: any, modified: any): any;
 }
+declare module "validation/common" {
+    export type DotvvmValidationContext = {
+        readonly valueToValidate: any;
+        readonly parentViewModel: any;
+        readonly parameters: any[];
+    };
+    export type DotvvmValidationObservableMetadata = DotvvmValidationElementMetadata[];
+    export type DotvvmValidationElementMetadata = {
+        element: HTMLElement;
+        dataType: string;
+        format: string;
+        domNodeDisposal: boolean;
+        elementValidationState: boolean;
+    };
+    export const errorsSymbol: unique symbol;
+    /** Checks if the value is null, undefined or a whitespace only string */
+    export function isEmpty(value: any): boolean;
+    export function getValidationMetadata(property: KnockoutObservable<any>): DotvvmValidationObservableMetadata;
+}
+declare module "utils/evaluator" {
+    /**
+     * Traverses provided context according to given path.
+     * @example / - returns context
+     * @example "" or null - returns context
+     * @example /exampleProp/A - returns prop A located withing property exampleProp located at provided context
+     * @example /exampleProp/B/1 - returns second item from collection B located within property exampleProp located at provided context
+     * @returns found property as unwrapped object
+     */
+    export function traverseContext(context: any, path: string): any;
+    export function findPathToChildObject(vm: any, child: any, path: string): string | null;
+    export function getDataSourceItems(viewModel: any): Array<KnockoutObservable<any>>;
+    export function wrapObservable(func: () => any, isArray?: boolean): KnockoutComputed<any>;
+    export const unwrapComputedProperty: (obs: any) => any;
+}
+declare module "validation/error" {
+    export const allErrors: ValidationError[];
+    export function detachAllErrors(): void;
+    export function getErrors<T>(o: KnockoutObservable<T> | null): ValidationError[];
+    export class ValidationError {
+        errorMessage: string;
+        propertyPath: string;
+        validatedObservable: KnockoutObservable<any>;
+        private constructor();
+        static attach(errorMessage: string, propertyPath: string, observable: KnockoutObservable<any>): ValidationError;
+        detach(): void;
+    }
+}
 declare module "state-manager" {
     import { DotvvmEvent } from "events";
     export const currentStateSymbol: unique symbol;
-    const notifySymbol: unique symbol;
+    export const notifySymbol: unique symbol;
     export const lastSetErrorSymbol: unique symbol;
     const updateSymbol: unique symbol;
     export function getIsViewModelUpdating(): boolean;
@@ -148,7 +192,6 @@ declare module "state-manager" {
         constructor(initialState: DeepReadonly<TViewModel>, stateUpdateEvent: DotvvmEvent<DeepReadonly<TViewModel>>);
         dispatchUpdate(): void;
         doUpdateNow(): void;
-        private startTime;
         private rerender;
         setState(newState: DeepReadonly<TViewModel>): DeepReadonly<TViewModel>;
         patchState(patch: Partial<TViewModel>): DeepReadonly<TViewModel>;
@@ -156,6 +199,14 @@ declare module "state-manager" {
     }
     export function unmapKnockoutObservables(viewModel: any): any;
 }
+declare module "serialization/deserialize" {
+    export function deserialize(viewModel: any, target?: any, deserializeAll?: boolean): any;
+    export function deserializePrimitive(viewModel: any, target?: any): any;
+    export function deserializeDate(viewModel: any, target?: any): any;
+    export function deserializeArray(viewModel: any, target?: any, deserializeAll?: boolean): any;
+    export function deserializeObject(viewModel: any, target: any, deserializeAll: boolean): any;
+    export function extendToObservableArrayIfRequired(observable: any): any;
+}
 declare module "serialization/serialize" {
     interface ISerializationOptions {
         serializeAll?: boolean;
@@ -177,25 +228,6 @@ declare module "postback/resourceLoader" {
     export function loadResourceList(resources: RenderedResourceList | undefined): Promise<void>;
     export function notifyModuleLoaded(id: number): void;
 }
-declare module "validation/common" {
-    export type DotvvmValidationContext = {
-        readonly valueToValidate: any;
-        readonly parentViewModel: any;
-        readonly parameters: any[];
-    };
-    export type DotvvmValidationObservableMetadata = DotvvmValidationElementMetadata[];
-    export type DotvvmValidationElementMetadata = {
-        element: HTMLElement;
-        dataType: string;
-        format: string;
-        domNodeDisposal: boolean;
-        elementValidationState: boolean;
-    };
-    export const ErrorsPropertyName = "validationErrors";
-    /** Checks if the value is null, undefined or a whitespace only string */
-    export function isEmpty(value: any): boolean;
-    export function getValidationMetadata(property: KnockoutObservable<any>): DotvvmValidationObservableMetadata;
-}
 declare module "binding-handlers/textbox-text" {
     const _default: {
         "dotvvm-textbox-text": {
@@ -233,13 +265,47 @@ declare module "binding-handlers/SSR-foreach" {
     };
     export default _default_2;
 }
-declare module "binding-handlers/introduce-alias" {
+declare module "viewModules/viewModuleManager" {
+    type ModuleCommand = (...args: any) => Promise<unknown>;
+    export const viewModulesSymbol: unique symbol;
+    export function registerViewModule(name: string, moduleObject: any): void;
+    export function registerViewModules(modules: {
+        [name: string]: any;
+    }): void;
+    export function initViewModule(name: string, viewIdOrElement: string | HTMLElement, rootElement: HTMLElement): ModuleContext;
+    export function callViewModuleCommand(viewIdOrElement: string | HTMLElement, commandName: string, args: any[], allowAsync?: boolean): any;
+    export function findComponent(viewIdOrElement: null | string | HTMLElement, name: string): [ModuleContext | null, DotvvmJsComponentFactory];
+    export function registerGlobalComponent(name: string, c: DotvvmJsComponentFactory): void;
+    export function registerNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string, command: ModuleCommand, rootElement: HTMLElement): void;
+    export function unregisterNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string): void;
+    export class ModuleContext {
+        readonly moduleName: string;
+        readonly elements: HTMLElement[];
+        readonly properties: {
+            [name: string]: any;
+        };
+        private readonly namedCommands;
+        module: any;
+        constructor(moduleName: string, elements: HTMLElement[], properties: {
+            [name: string]: any;
+        });
+        registerNamedCommand: (name: string, command: (...args: any[]) => Promise<any>) => void;
+        unregisterNamedCommand: (name: string) => void;
+    }
+}
+declare module "binding-handlers/markup-controls" {
+    export function wrapControlProperties(valueAccessor: () => any): any;
     const _default_3: {
         'dotvvm-with-control-properties': {
             init: (element: HTMLElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => {
                 controlsDescendantBindings: boolean;
             };
         };
+        'dotvvm-with-view-modules': {
+            init: (element: HTMLElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => {
+                controlsDescendantBindings: boolean;
+            } | undefined;
+        };
     };
     export default _default_3;
 }
@@ -265,11 +331,11 @@ declare module "binding-handlers/checkbox" {
         'dotvvm-checkbox-updateAfterPostback': {
             init(element: HTMLElement, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor | undefined): void;
         };
-        'dotvvm-checked-pointer': {
-            init(): void;
-        };
+        'dotvvm-checked-pointer': {};
         "dotvvm-CheckState": {
-            init(element: HTMLElement, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor | undefined, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined): void;
+            init: ((element: any, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor | undefined, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => void | {
+                controlsDescendantBindings: boolean;
+            }) | undefined;
             update(element: any, valueAccessor: () => any): void;
         };
         "dotvvm-checkedItems": {
@@ -317,35 +383,9 @@ declare module "binding-handlers/gridviewdataset" {
     };
     export default _default_8;
 }
-declare module "viewModules/viewModuleManager" {
-    type ModuleCommand = (...args: any) => Promise<unknown>;
-    export const viewModulesSymbol: unique symbol;
-    export function registerViewModule(name: string, moduleObject: any): void;
-    export function registerViewModules(modules: {
-        [name: string]: any;
-    }): void;
-    export function initViewModule(name: string, viewIdOrElement: string | HTMLElement, rootElement: HTMLElement): ModuleContext;
-    export function callViewModuleCommand(viewIdOrElement: string | HTMLElement, commandName: string, args: any[]): any;
-    export function registerNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string, command: ModuleCommand, rootElement: HTMLElement): void;
-    export function unregisterNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string): void;
-    export class ModuleContext {
-        readonly moduleName: string;
-        readonly elements: HTMLElement[];
-        readonly properties: {
-            [name: string]: any;
-        };
-        private readonly namedCommands;
-        module: any;
-        constructor(moduleName: string, elements: HTMLElement[], properties: {
-            [name: string]: any;
-        });
-        registerNamedCommand: (name: string, command: (...args: any[]) => Promise<any>) => void;
-        unregisterNamedCommand: (name: string) => void;
-    }
-}
-declare module "binding-handlers/with-view-modules" {
+declare module "binding-handlers/named-command" {
     const _default_9: {
-        'dotvvm-with-view-modules': {
+        'dotvvm-named-command': {
             init: (element: HTMLElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => {
                 controlsDescendantBindings: boolean;
             };
@@ -353,16 +393,22 @@ declare module "binding-handlers/with-view-modules" {
     };
     export default _default_9;
 }
-declare module "binding-handlers/named-command" {
+declare module "binding-handlers/file-upload" {
     const _default_10: {
-        'dotvvm-named-command': {
-            init: (element: HTMLElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => {
-                controlsDescendantBindings: boolean;
-            };
+        "dotvvm-FileUpload": {
+            init: (element: HTMLInputElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => void;
         };
     };
     export default _default_10;
 }
+declare module "binding-handlers/js-component" {
+    const _default_11: {
+        "dotvvm-js-component": {
+            init(element: HTMLInputElement, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor | undefined): void;
+        };
+    };
+    export default _default_11;
+}
 declare module "binding-handlers/all-handlers" {
     type KnockoutHandlerDictionary = {
         [name: string]: KnockoutBindingHandler;
@@ -394,23 +440,21 @@ declare module "dotvvm-base" {
     export function initBindings(): void;
 }
 declare module "DotVVM.Globalize" {
+    import { parseDate as serializationParseDate } from "serialization/date";
     export function format(format: string, ...values: any[]): string;
     type GlobalizeFormattable = null | undefined | string | Date | number;
     export function formatString(format: string | null | undefined, value: GlobalizeFormattable | KnockoutObservable<GlobalizeFormattable>): string;
     export function parseNumber(value: string): number;
     export function parseDate(value: string, format: string, previousValue?: Date): Date | null;
-    export const parseDotvvmDate: typeof parseDate;
-    export function bindingDateToString(value: KnockoutObservable<string | Date> | string | Date, format?: string): "" | KnockoutComputed<string>;
-    export function bindingNumberToString(value: KnockoutObservable<string | number> | string | number, format?: string): "" | KnockoutComputed<string>;
-}
-declare module "DotVVM.Polyfills" {
-    export default function (): void;
+    export const parseDotvvmDate: typeof serializationParseDate;
+    export function bindingDateToString(value: KnockoutObservable<string | Date> | string | Date | null | undefined, format?: string): KnockoutComputed<string>;
+    export function bindingNumberToString(value: KnockoutObservable<string | number> | string | number | null | undefined, format?: string): KnockoutComputed<string>;
 }
 declare var compileConstants: {
     /** If the compiled bundle is for SPA applications */
     isSpa: boolean;
-    /** If the compiled bundle is for legacy browser that don't support modules (and other new EcmaScript features)  */
-    nomodules: boolean;
+    /** If the compiled bundle is unminified  */
+    debug: boolean;
 };
 declare module "utils/uri" {
     export function removeVirtualDirectoryFromUrl(url: string): string;
@@ -423,14 +467,14 @@ declare module "postback/http" {
         readonly result: T;
         readonly response?: Response;
     };
-    export function getJSON<T>(url: string, spaPlaceHolderUniqueId?: string, additionalHeaders?: {
+    export function getJSON<T>(url: string, spaPlaceHolderUniqueId?: string, signal?: AbortSignal, additionalHeaders?: {
         [key: string]: string;
     }): Promise<WrappedResponse<T>>;
-    export function postJSON<T>(url: string, postData: any, additionalHeaders?: {
+    export function postJSON<T>(url: string, postData: any, signal: AbortSignal | undefined, additionalHeaders?: {
         [key: string]: string;
     }): Promise<WrappedResponse<T>>;
     export function fetchJson<T>(url: string, init: RequestInit): Promise<WrappedResponse<T>>;
-    export function fetchCsrfToken(): Promise<string>;
+    export function fetchCsrfToken(signal: AbortSignal | undefined): Promise<string>;
     export function retryOnInvalidCsrfToken<TResult>(postbackFunction: () => Promise<TResult>, iteration?: number, customErrorHandler?: () => void): Promise<TResult>;
 }
 declare module "postback/counter" {
@@ -443,12 +487,6 @@ declare module "postback/redirect" {
     export function performRedirect(url: string, replace: boolean, allowSpa: boolean): Promise<any>;
     export function handleRedirect(options: PostbackOptions, resultObject: any, response: Response, replace?: boolean): Promise<DotvvmRedirectEventArgs>;
 }
-declare module "utils/evaluator" {
-    export function evaluateOnViewModel(context: any, expression: string): any;
-    export function getDataSourceItems(viewModel: any): Array<KnockoutObservable<any>>;
-    export function wrapObservable(func: () => any, isArray?: boolean): KnockoutComputed<any>;
-    export const unwrapComputedProperty: (obs: any) => any;
-}
 declare module "postback/gate" {
     export function isPostbackDisabled(postbackId: number): boolean;
     export function enablePostbacks(): void;
@@ -471,18 +509,6 @@ declare module "validation/validators" {
     };
     export const validators: DotvvmValidatorSet;
 }
-declare module "validation/error" {
-    export const allErrors: ValidationError[];
-    export function detachAllErrors(): void;
-    export function getErrors<T>(o: KnockoutObservable<T> | null): ValidationError[];
-    export class ValidationError {
-        errorMessage: string;
-        validatedObservable: KnockoutObservable<any>;
-        private constructor();
-        static attach(errorMessage: string, observable: KnockoutObservable<any>): ValidationError;
-        detach(): void;
-    }
-}
 declare module "postback/internal-handlers" {
     export const isPostbackRunning: KnockoutObservable<boolean>;
     export const suppressOnDisabledElementHandler: DotvvmPostbackHandler;
@@ -536,35 +562,59 @@ declare module "validation/actions" {
 declare module "validation/validation" {
     import { ValidationError } from "validation/error";
     import { DotvvmEvent } from "events";
-    type DotvvmValidationErrorsChangedEventArgs = PostbackOptions & {
+    type DotvvmValidationErrorsChangedEventArgs = Partial<PostbackOptions> & {
         readonly allErrors: ValidationError[];
     };
     export const events: {
         validationErrorsChanged: DotvvmEvent<DotvvmValidationErrorsChangedEventArgs>;
     };
     export const globalValidationObject: {
+        /** Dictionary of client-side validation rules. Add new items to this object if you want to add support for new validation rules */
         rules: {
             [name: string]: import("validation/validators").DotvvmValidator;
         };
+        /** List of all currently active errors */
         errors: ValidationError[];
         events: {
             validationErrorsChanged: DotvvmEvent<DotvvmValidationErrorsChangedEventArgs>;
         };
+        /** Add the specified list of validation errors. `dotvvm.validation.addErrors([ { errorMessage: "test error", propertyPath: "/LoginForm/Name" } ])` */
+        addErrors: typeof addErrors;
+        /** Removes errors from the specified properties.
+         *  The errors are removed recursively, so calling `dotvvm.validation.removeErrors("/")` removes all errors in the page,
+         *  `dotvvm.validation.removeErrors("/Detail")` removes all errors from the object in property root.Detail */
+        removeErrors: typeof removeErrors;
     };
     export function init(): void;
+    export type ValidationErrorDescriptor = {
+        /** Error to be displayed to the user */
+        errorMessage: string;
+        /** Path in the view model to the annotated property, for example `/LoginPage/Name` */
+        propertyPath: string;
+    };
+    export type AddErrorsOptions = {
+        /** Root object from which are the property paths resolved. By default it's the root view model of the page */
+        root?: KnockoutObservable<any> | any;
+        /** When set to false, the validationErrorsChanged is not triggered. By default it's true -> the error is triggered.
+         *  The validationErrorsChanged event controls the `Validator`s in the DotHTML page, so when it's not triggered, the change won't be visible. */
+        triggerErrorsChanged?: false;
+    };
+    export function removeErrors(...paths: string[]): void;
+    export function addErrors(errors: ValidationErrorDescriptor[], options?: AddErrorsOptions): void;
     /**
      * Adds validation errors from the server to the appropriate arrays
      */
-    export function showValidationErrorsFromServer(dataContext: any, path: string, serverResponseObject: any, options: PostbackOptions): void;
+    export function showValidationErrorsFromServer(serverResponseObject: any, options: PostbackOptions): void;
 }
 declare module "postback/postbackCore" {
+    export function throwIfAborted(options: PostbackOptions): void;
     export function getLastStartedPostbackId(): number;
     export function postbackCore(options: PostbackOptions, path: string[], command: string, controlUniqueId: string, context: any, commandArgs?: any[]): Promise<PostbackCommitFunction>;
 }
 declare module "postback/postback" {
-    export function postBack(sender: HTMLElement, path: string[], command: string, controlUniqueId: string, context?: any, handlers?: ClientFriendlyPostbackHandlerConfiguration[], commandArgs?: any[]): Promise<DotvvmAfterPostBackEventArgs>;
+    export function postBack(sender: HTMLElement, path: string[], command: string, controlUniqueId: string, context?: any, handlers?: ClientFriendlyPostbackHandlerConfiguration[], commandArgs?: any[], abortSignal?: AbortSignal): Promise<DotvvmAfterPostBackEventArgs>;
     type MaybePromise<T> = Promise<T> | T;
-    export function applyPostbackHandlers(next: (options: PostbackOptions) => MaybePromise<PostbackCommitFunction | any>, sender: HTMLElement, handlerConfigurations?: ClientFriendlyPostbackHandlerConfiguration[], args?: any[], context?: any, viewModel?: any): Promise<DotvvmAfterPostBackEventArgs>;
+    export function applyPostbackHandlers(next: (options: PostbackOptions) => MaybePromise<PostbackCommitFunction | any>, sender: HTMLElement, handlerConfigurations?: ClientFriendlyPostbackHandlerConfiguration[], args?: any[], context?: any, abortSignal?: AbortSignal): Promise<DotvvmAfterPostBackEventArgs>;
     export function isPostbackHandler(obj: any): obj is DotvvmPostbackHandler;
     export function sortHandlers(handlers: DotvvmPostbackHandler[]): DotvvmPostbackHandler[];
 }
@@ -579,11 +629,11 @@ declare module "spa/spa" {
     export function handleSpaNavigationCore(url: string | null, sender?: HTMLElement, handlePageNavigating?: (url: string) => void): Promise<DotvvmNavigationEventArgs>;
 }
 declare module "binding-handlers/register" {
-    const _default_11: () => void;
-    export default _default_11;
+    const _default_12: () => void;
+    export default _default_12;
 }
 declare module "postback/staticCommand" {
-    export function staticCommandPostback(sender: HTMLElement, command: string, args: any[], options: PostbackOptions): Promise<any>;
+    export function staticCommandPostback(command: string, args: any[], options: PostbackOptions): Promise<any>;
 }
 declare module "controls/routeLink" {
     export function buildRouteUrl(routePath: string, params: any): string;
@@ -591,20 +641,7 @@ declare module "controls/routeLink" {
 }
 declare module "controls/fileUpload" {
     export function showUploadDialog(sender: HTMLElement): void;
-    export function createUploadId(sender: HTMLElement, iframe: HTMLElement): void;
-    export function reportProgress(targetControlId: any, isBusy: boolean, progress: number, result: DotvvmStaticCommandResponse<DotvvmFileUploadData[]> | string): void;
-    type DotvvmFileUploadData = {
-        FileId: KnockoutObservable<string>;
-        FileName: KnockoutObservable<string>;
-        FileSize: KnockoutObservable<DotvvmFileSize>;
-        IsFileTypeAllowed: KnockoutObservable<boolean>;
-        IsMaxSizeExceeded: KnockoutObservable<boolean>;
-        IsAllowed: KnockoutObservable<boolean>;
-    };
-    type DotvvmFileSize = {
-        Bytes: KnockoutObservable<number>;
-        FormattedText: KnockoutObservable<string>;
-    };
+    export function reportProgress(inputControl: HTMLInputElement, isBusy: boolean, progress: number, result: DotvvmStaticCommandResponse<DotvvmFileUploadData[]> | string): void;
 }
 declare module "api/eventHub" {
     export function notify(id: string): void;
@@ -617,9 +654,69 @@ declare module "api/api" {
     export function invoke<T>(target: any, methodName: string, argsProvider: () => any[], refreshTriggers: (args: any[]) => Array<KnockoutObservable<any> | string>, notifyTriggers: (args: any[]) => string[], element: HTMLElement, sharingKeyProvider: (args: any[]) => string[]): ApiComputed<T>;
     export function refreshOn<T>(value: ApiComputed<T>, watch: KnockoutObservable<any>): ApiComputed<T>;
 }
+declare module "metadata/metadataHelper" {
+    export function getTypeId(viewModel: object): string | undefined;
+    export function getTypeMetadata(typeId: string): TypeMetadata;
+    export function getEnumMetadata(enumMetadataId: string): EnumTypeMetadata;
+    export function getEnumValue(identifier: string | number, enumMetadataId: string): number | undefined;
+}
+declare module "collections/sortingHelper" {
+    type ElementType = string | number | boolean;
+    export const orderBy: <T>(array: T[], selector: (item: T) => ElementType, typeId: string) => T[];
+    export const orderByDesc: <T>(array: T[], selector: (item: T) => ElementType, typeId: string) => T[];
+}
+declare module "collections/arrayHelper" {
+    import { orderBy, orderByDesc } from "collections/sortingHelper";
+    export { add, addOrUpdate, addRange, clear, distinct, firstOrDefault, insert, insertRange, lastOrDefault, max, min, orderBy, orderByDesc, removeAll, removeAt, removeFirst, removeLast, removeRange, reverse, setItem };
+    function add<T>(observable: any, element: T): void;
+    function addOrUpdate<T>(observable: any, element: T, matcher: (e: T) => boolean, updater: (e: T) => T): void;
+    function addRange<T>(observable: any, elements: T[]): void;
+    function clear(observable: any): void;
+    function distinct<T>(array: T[]): T[];
+    function firstOrDefault<T>(array: T[], predicate: (s: T) => boolean): T | null;
+    function insert<T>(observable: any, index: number, element: T): void;
+    function insertRange<T>(observable: any, index: number, elements: T[]): void;
+    function lastOrDefault<T>(array: T[], predicate: (s: T) => boolean): T | null;
+    function max<T>(array: T[], selector: (item: T) => number, throwIfEmpty: boolean): number | null;
+    function min<T>(array: T[], selector: (item: T) => number, throwIfEmpty: boolean): number | null;
+    function removeAt<T>(observable: any, index: number): void;
+    function removeAll<T>(observable: any, predicate: (s: T) => boolean): void;
+    function removeRange<T>(observable: any, index: number, length: number): void;
+    function removeFirst<T>(observable: any, predicate: (s: T) => boolean): void;
+    function removeLast<T>(observable: any, predicate: (s: T) => boolean): void;
+    function reverse<T>(observable: any): void;
+    function setItem<T>(observable: any, index: number, value: T): void;
+}
+declare module "collections/dictionaryHelper" {
+    type Dictionary<Key, Value> = {
+        Key: Key;
+        Value: Value;
+    }[];
+    export function clear(observable: any): void;
+    export function containsKey<Key, Value>(dictionary: Dictionary<Key, Value>, identifier: Key): boolean;
+    export function getItem<Key, Value>(dictionary: Dictionary<Key, Value>, identifier: Key): Value;
+    export function remove<Key, Value>(observable: any, identifier: Key): boolean;
+    export function setItem<Key, Value>(observable: any, identifier: Key, value: Value): void;
+}
+declare module "utils/stringHelper" {
+    export function contains(haystack: string, needle: string, options: string): boolean;
+    export function endsWith(haystack: string, needle: string, options: string): boolean;
+    export function startsWith(haystack: string, needle: string, options: string): boolean;
+    export function indexOf(haystack: string, startIndex: number, needle: string, options: string): number;
+    export function lastIndexOf(haystack: string, startIndex: number, needle: string, options: string): number;
+    export function split(text: string, delimiter: string, options: string): string[];
+    export function join<T>(elements: T[], delimiter: string): string;
+    export function format(pattern: string, expressions: any[]): string;
+    export function trimStart(text: string, char: string): string;
+    export function trimEnd(text: string, char: string): string;
+}
+declare module "utils/dateTimeHelper" {
+    export function toBrowserLocalTime(value: KnockoutObservable<string | null>): KnockoutComputed<string | null>;
+}
 declare module "dotvvm-root" {
     import { getCulture } from "dotvvm-base";
     import * as events from "events";
+    import * as validation from "validation/validation";
     import { postBack } from "postback/postback";
     import { serialize } from "serialization/serialize";
     import { serializeDate, parseDate } from "serialization/date";
@@ -638,6 +735,8 @@ declare module "dotvvm-root" {
     import * as viewModuleManager from "viewModules/viewModuleManager";
     import { notifyModuleLoaded } from "postback/resourceLoader";
     import { logError, logWarning, logInfo, logInfoVerbose, logPostBackScriptError } from "utils/logging";
+    import * as metadataHelper from "metadata/metadataHelper";
+    import { StateManager } from "state-manager";
     function init(culture: string): void;
     const dotvvmExports: {
         getCulture: typeof getCulture;
@@ -648,7 +747,6 @@ declare module "dotvvm-root" {
         fileUpload: {
             reportProgress: typeof fileUpload.reportProgress;
             showUploadDialog: typeof fileUpload.showUploadDialog;
-            createUploadId: typeof fileUpload.createUploadId;
         };
         api: {
             invoke: typeof api.invoke;
@@ -671,13 +769,16 @@ declare module "dotvvm-root" {
             };
             errors: import("validation/error").ValidationError[];
             events: {
-                validationErrorsChanged: events.DotvvmEvent<PostbackOptions & {
+                validationErrorsChanged: events.DotvvmEvent<Partial<PostbackOptions> & {
                     readonly allErrors: import("validation/error").ValidationError[];
                 }>;
             };
+            addErrors: typeof validation.addErrors;
+            removeErrors: typeof validation.removeErrors;
         };
         postBack: typeof postBack;
         init: typeof init;
+        registerGlobalComponent: typeof viewModuleManager.registerGlobalComponent;
         isPostbackRunning: KnockoutObservable<boolean>;
         events: Partial<typeof spaEvents> & typeof events;
         viewModels: {
@@ -696,6 +797,12 @@ declare module "dotvvm-root" {
             parseDate: typeof parseDate;
             deserialize: typeof deserialize;
         };
+        metadata: {
+            getTypeId: typeof metadataHelper.getTypeId;
+            getTypeMetadata: typeof metadataHelper.getTypeMetadata;
+            getEnumMetadata: typeof metadataHelper.getEnumMetadata;
+            getEnumValue: typeof metadataHelper.getEnumValue;
+        };
         viewModules: {
             registerOne: typeof viewModuleManager.registerViewModule;
             init: typeof viewModuleManager.initViewModule;
@@ -713,9 +820,13 @@ declare module "dotvvm-root" {
             logPostBackScriptError: typeof logPostBackScriptError;
             level: "normal" | "verbose";
         };
+        translations: any;
+        StateManager: typeof StateManager;
+        DotvvmEvent: typeof events.DotvvmEvent;
     };
     global {
         const dotvvm: typeof dotvvmExports & {
+            debug?: true;
             isSpaReady?: typeof isSpaReady;
             handleSpaNavigation?: typeof handleSpaNavigation;
         };
@@ -725,7 +836,7 @@ declare module "dotvvm-root" {
     }
     export default dotvvmExports;
 }
-declare type PostbackCommitFunction = (...args: any) => Promise<DotvvmAfterPostBackEventArgs>;
+declare type PostbackCommitFunction = () => Promise<DotvvmAfterPostBackEventArgs>;
 declare type DotvvmPostbackHandler = {
     execute(next: () => Promise<PostbackCommitFunction>, options: PostbackOptions): Promise<PostbackCommitFunction>;
     name?: string;
@@ -735,7 +846,7 @@ declare type DotvvmPostbackHandler = {
 declare type DotvvmPostbackErrorLike = {
     readonly reason: DotvvmPostbackErrorReason;
 };
-declare type DotvvmPostbackErrorReason = {
+declare type DotvvmPostbackErrorReason = ({
     type: 'handler';
     handlerName: string;
     message?: string;
@@ -760,7 +871,13 @@ declare type DotvvmPostbackErrorReason = {
     type: 'validation';
     responseObject: any;
     response?: Response;
-} & {
+} | {
+    type: 'abort';
+} | {
+    type: 'redirect';
+    responseObject: any;
+    response?: Response;
+}) & {
     options?: PostbackOptions;
 };
 declare type PostbackCommandType = "postback" | "staticCommand" | "spaNavigation";
@@ -770,8 +887,10 @@ declare type PostbackOptions = {
     readonly args: any[];
     readonly sender?: HTMLElement;
     readonly viewModel?: any;
+    readonly knockoutContext?: any;
     serverResponseObject?: any;
     validationTargetPath?: string;
+    abortSignal?: AbortSignal;
 };
 declare type DotvvmErrorEventArgs = PostbackOptions & {
     readonly response?: Response;
@@ -920,6 +1039,7 @@ declare type DotvvmObservable<T> = DeepKnockoutObservable<T> & {
 declare type RootViewModel = {
     $type: string;
     $csrfToken?: string;
+    [name: string]: any;
 };
 declare type TypeMap = {
     [typeId: string]: TypeMetadata;
@@ -935,6 +1055,7 @@ declare type EnumTypeMetadata = {
     values: {
         [name: string]: number;
     };
+    isFlags?: boolean;
 };
 declare type TypeMetadata = ObjectTypeMetadata | EnumTypeMetadata;
 declare type PropertyMetadata = {
@@ -967,3 +1088,47 @@ declare type CoerceResult = CoerceErrorType | {
     wasCoerced?: boolean;
     isError?: false;
 };
+declare type DotvvmFileUploadCollection = {
+    Files: KnockoutObservableArray<KnockoutObservable<DotvvmFileUploadData>>;
+    Progress: KnockoutObservable<number>;
+    Error: KnockoutObservable<string>;
+    IsBusy: KnockoutObservable<boolean>;
+};
+declare type DotvvmFileUploadData = {
+    FileId: KnockoutObservable<string>;
+    FileName: KnockoutObservable<string>;
+    FileSize: KnockoutObservable<DotvvmFileSize>;
+    IsFileTypeAllowed: KnockoutObservable<boolean>;
+    IsMaxSizeExceeded: KnockoutObservable<boolean>;
+    IsAllowed: KnockoutObservable<boolean>;
+};
+declare type DotvvmFileSize = {
+    Bytes: KnockoutObservable<number>;
+    FormattedText: KnockoutObservable<string>;
+};
+declare type DotvvmJsComponent = {
+    updateProps(p: {
+        [key: string]: any;
+    }): void;
+    dispose(): void;
+};
+declare type DotvvmJsComponentFactory = {
+    create(element: HTMLElement, props: {
+        [key: string]: any;
+    }, commands: {
+        [key: string]: (args: any[]) => Promise<any>;
+    }, templates: {
+        [key: string]: string;
+    }, // TODO
+    setProps: (p: {
+        [key: string]: any;
+    }) => void): DotvvmJsComponent;
+};
+declare type DotvvmViewModuleCommandName = `${'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z'}${string}`;
+declare type DotvvmViewModule = {
+    $controls?: {
+        [name: string]: DotvvmJsComponentFactory;
+    };
+    $dispose?: (context: any) => void;
+    [commandName: DotvvmViewModuleCommandName]: (...args: any[]) => Promise<any> | any;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotvvm-types",
-  "version": "3.0.2",
+  "version": "4.1.0-preview04-final",
   "description": "MVVM framework for ASP.NET",
   "types": "index.d.ts",
   "repository": {
@@ -13,9 +13,6 @@
     "url": "https://github.com/riganti/dotvvm/issues"
   },
   "homepage": "https://github.com/riganti/dotvvm#readme",
-  "devDependencies": {
-    "typescript": "^4.0.3"
-  },
   "dependencies": {
     "@types/knockout": "^3.4.69"
   }