dotvvm-types 3.0.0-preview01 → 4.0.7

package/index.d.ts

@@ -1,6 +1,36 @@
+/// <reference path="../../Resources/Scripts/typings/globalize/globalize.d.ts" />
+declare module "shared-classes" {
+    export class DotvvmPostbackError {
+        reason: DotvvmPostbackErrorReason;
+        constructor(reason: DotvvmPostbackErrorReason);
+        toString(): string;
+    }
+    export class CoerceError implements CoerceErrorType {
+        message: string;
+        path: string;
+        isError: true;
+        wasCoerced: false;
+        get value(): never;
+        constructor(message: string, path?: string);
+        static generic(value: any, type: TypeDefinition): CoerceError;
+        prependPathFragment(fragment: string): void;
+    }
+}
+declare module "utils/logging" {
+    type LogLevel = "normal" | "verbose";
+    export const level: LogLevel;
+    export function logInfoVerbose(area: string, ...args: any[]): void;
+    export function logInfo(area: string, ...args: any[]): void;
+    export function logWarning(area: string, ...args: any[]): void;
+    export function logError(area: string, ...args: any[]): void;
+    export function logPostBackScriptError(err: any): void;
+}
 declare module "serialization/date" {
-    export function parseDate(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;
 }
 declare module "utils/dom" {
     export const getElementByDotvvmId: (id: string) => HTMLElement;
@@ -18,27 +48,169 @@ 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 keys: {
         (o: object): string[];
         (o: {}): string[];
     };
 }
+declare module "metadata/typeMap" {
+    export function getTypeInfo(typeId: string): TypeMetadata;
+    export function getObjectTypeInfo(typeId: string): ObjectTypeMetadata;
+    export function getKnownTypes(): string[];
+    export function updateTypeInfo(newTypes: TypeMap | undefined): void;
+    export function replaceTypeInfo(newTypes: TypeMap | undefined): void;
+}
+declare module "events" {
+    export class DotvvmEvent<T> {
+        readonly name: string;
+        private readonly triggerMissedEventsOnSubscribe;
+        private handlers;
+        private history;
+        constructor(name: string, triggerMissedEventsOnSubscribe?: boolean);
+        subscribe(handler: (data: T) => void): void;
+        subscribeOnce(handler: (data: T) => void): void;
+        unsubscribe(handler: (data: T) => void): void;
+        trigger(data: T): void;
+    }
+    export const init: DotvvmEvent<DotvvmInitEventArgs>;
+    export const initCompleted: DotvvmEvent<DotvvmInitCompletedEventArgs>;
+    export const beforePostback: DotvvmEvent<DotvvmBeforePostBackEventArgs>;
+    export const afterPostback: DotvvmEvent<DotvvmAfterPostBackEventArgs>;
+    export const error: DotvvmEvent<DotvvmErrorEventArgs>;
+    export const redirect: DotvvmEvent<DotvvmRedirectEventArgs>;
+    export const postbackHandlersStarted: DotvvmEvent<PostbackOptions>;
+    export const postbackHandlersCompleted: DotvvmEvent<PostbackOptions>;
+    export const postbackResponseReceived: DotvvmEvent<DotvvmPostbackResponseReceivedEventArgs>;
+    export const postbackCommitInvoked: DotvvmEvent<DotvvmPostbackCommitInvokedEventArgs>;
+    export const postbackViewModelUpdated: DotvvmEvent<DotvvmPostbackViewModelUpdatedEventArgs>;
+    export const postbackRejected: DotvvmEvent<DotvvmPostbackRejectedEventArgs>;
+    export const staticCommandMethodInvoking: DotvvmEvent<DotvvmStaticCommandMethodInvokingEventArgs>;
+    export const staticCommandMethodInvoked: DotvvmEvent<DotvvmStaticCommandMethodInvokedEventArgs>;
+    export const staticCommandMethodFailed: DotvvmEvent<DotvvmStaticCommandMethodFailedEventArgs>;
+    export const newState: DotvvmEvent<RootViewModel>;
+}
+declare module "metadata/primitiveTypes" {
+    type PrimitiveTypes = {
+        [name: string]: {
+            tryCoerce: (value: any) => CoerceResult | undefined;
+        };
+    };
+    export const primitiveTypes: PrimitiveTypes;
+}
+declare module "metadata/coercer" {
+    /**
+     * Validates type of value
+     * @param type Expected type of type value.
+     * @param originalValue Value that is known to be valid instance of type. It is used to perform incremental validation.
+     */
+    export function tryCoerce(value: any, type: TypeDefinition, originalValue?: any): CoerceResult;
+    export function coerce(value: any, type: TypeDefinition, originalValue?: any): any;
+}
+declare module "postback/updater" {
+    export function cleanUpdatedControls(resultObject: any, updatedControls?: any): any;
+    export function restoreUpdatedControls(resultObject: any, updatedControls: any): void;
+    export function updateViewModelAndControls(resultObject: any): void;
+    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 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 "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;
+    export const notifySymbol: unique symbol;
+    export const lastSetErrorSymbol: unique symbol;
+    const updateSymbol: unique symbol;
+    export function getIsViewModelUpdating(): boolean;
+    export type UpdatableObjectExtensions<T> = {
+        [notifySymbol]: (newValue: T) => void;
+        [currentStateSymbol]: T;
+        [updateSymbol]?: UpdateDispatcher<T>;
+    };
+    export class StateManager<TViewModel extends {
+        $type?: TypeDefinition;
+    }> {
+        stateUpdateEvent: DotvvmEvent<DeepReadonly<TViewModel>>;
+        readonly stateObservable: DeepKnockoutObservable<TViewModel>;
+        private _state;
+        get state(): DeepReadonly<TViewModel>;
+        private _isDirty;
+        get isDirty(): boolean;
+        private _currentFrameNumber;
+        constructor(initialState: DeepReadonly<TViewModel>, stateUpdateEvent: DotvvmEvent<DeepReadonly<TViewModel>>);
+        dispatchUpdate(): void;
+        doUpdateNow(): void;
+        private rerender;
+        setState(newState: DeepReadonly<TViewModel>): DeepReadonly<TViewModel>;
+        patchState(patch: Partial<TViewModel>): DeepReadonly<TViewModel>;
+        update(updater: StateUpdate<TViewModel>): DeepReadonly<TViewModel>;
+    }
+    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;
-}
-declare module "serialization/typeValidation" {
-    export function validateType(value: any, type: string): boolean;
+    export function extendToObservableArrayIfRequired(observable: any): any;
 }
 declare module "serialization/serialize" {
     interface ISerializationOptions {
         serializeAll?: boolean;
-        oneLevel?: boolean;
         ignoreSpecialProperties?: boolean;
         pathMatcher?: (vm: any) => boolean;
         path?: string[];
@@ -46,6 +218,7 @@ declare module "serialization/serialize" {
         restApiTarget?: boolean;
     }
     export function serialize(viewModel: any, opt?: ISerializationOptions): any;
+    export function serializeCore(viewModel: any, opt?: ISerializationOptions): any;
 }
 declare module "postback/resourceLoader" {
     export type RenderedResourceList = {
@@ -54,25 +227,7 @@ declare module "postback/resourceLoader" {
     export function registerResources(rs: string[] | null | undefined): void;
     export const getRenderedResources: () => string[];
     export function loadResourceList(resources: RenderedResourceList | undefined): Promise<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;
+    export function notifyModuleLoaded(id: number): void;
 }
 declare module "binding-handlers/textbox-text" {
     const _default: {
@@ -111,13 +266,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;
 }
@@ -138,56 +327,16 @@ declare module "binding-handlers/enable" {
     };
     export default _default_5;
 }
-declare module "events" {
-    export class DotvvmEvent<T> {
-        readonly name: string;
-        private readonly triggerMissedEventsOnSubscribe;
-        private handlers;
-        private history;
-        constructor(name: string, triggerMissedEventsOnSubscribe?: boolean);
-        subscribe(handler: (data: T) => void): void;
-        subscribeOnce(handler: (data: T) => void): void;
-        unsubscribe(handler: (data: T) => void): void;
-        trigger(data: T): void;
-    }
-    export const init: DotvvmEvent<DotvvmEventArgs>;
-    export const beforePostback: DotvvmEvent<DotvvmBeforePostBackEventArgs>;
-    export const afterPostback: DotvvmEvent<DotvvmAfterPostBackEventArgs>;
-    export const error: DotvvmEvent<DotvvmErrorEventArgs>;
-    export const redirect: DotvvmEvent<DotvvmRedirectEventArgs>;
-    export const postbackHandlersStarted: DotvvmEvent<{}>;
-    export const postbackHandlersCompleted: DotvvmEvent<{}>;
-    export const postbackResponseReceived: DotvvmEvent<{}>;
-    export const postbackCommitInvoked: DotvvmEvent<{}>;
-    export const postbackViewModelUpdated: DotvvmEvent<{}>;
-    export const postbackRejected: DotvvmEvent<{}>;
-    export const staticCommandMethodInvoking: DotvvmEvent<{
-        args: any[];
-        command: string;
-    }>;
-    export const staticCommandMethodInvoked: DotvvmEvent<{
-        args: any[];
-        command: string;
-        result: any;
-        xhr: XMLHttpRequest;
-    }>;
-    export const staticCommandMethodFailed: DotvvmEvent<{
-        args: any[];
-        command: string;
-        xhr: XMLHttpRequest;
-        error?: any;
-    }>;
-}
 declare module "binding-handlers/checkbox" {
     const _default_6: {
         '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": {
@@ -225,6 +374,42 @@ declare module "binding-handlers/update-progress" {
     };
     export default _default_7;
 }
+declare module "binding-handlers/gridviewdataset" {
+    const _default_8: {
+        "dotvvm-gridviewdataset": {
+            init: (element: Node, valueAccessor: () => any, allBindings: KnockoutAllBindingsAccessor | undefined, _viewModel: any, bindingContext: KnockoutBindingContext | undefined) => {
+                controlsDescendantBindings: boolean;
+            };
+        };
+    };
+    export default _default_8;
+}
+declare module "binding-handlers/named-command" {
+    const _default_9: {
+        'dotvvm-named-command': {
+            init: (element: HTMLElement, valueAccessor: () => any, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext | undefined) => {
+                controlsDescendantBindings: boolean;
+            };
+        };
+    };
+    export default _default_9;
+}
+declare module "binding-handlers/file-upload" {
+    const _default_10: {
+        "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;
@@ -236,112 +421,99 @@ declare module "spa/events" {
     import { DotvvmEvent } from "events";
     export const spaNavigating: DotvvmEvent<DotvvmSpaNavigatingEventArgs>;
     export const spaNavigated: DotvvmEvent<DotvvmSpaNavigatedEventArgs>;
+    export const spaNavigationFailed: DotvvmEvent<DotvvmSpaNavigationFailedEventArgs>;
 }
 declare module "dotvvm-base" {
-    export function getViewModel(): RootViewModel;
+    import { StateManager } from "state-manager";
+    export function getViewModel(): DeepKnockoutObservableObject<RootViewModel>;
     export function getViewModelCacheId(): string | undefined;
     export function getViewModelCache(): any;
-    export function getViewModelObservable(): KnockoutObservable<RootViewModel>;
+    export function getViewModelObservable(): DeepKnockoutObservable<RootViewModel>;
     export function getInitialUrl(): string;
     export function getVirtualDirectory(): string;
     export function replaceViewModel(vm: RootViewModel): void;
+    export function getState(): Readonly<RootViewModel>;
     export function updateViewModelCache(viewModelCacheId: string, viewModelCache: any): void;
     export function clearViewModelCache(): void;
-    export function getValidationRules(): ValidationRuleTable;
     export function getCulture(): string;
+    export function getStateManager(): StateManager<RootViewModel>;
     export function initCore(culture: string): void;
     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 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 "createPostbackArgs" {
-    export function createPostbackArgs(options: PostbackOptions): {
-        postbackClientId: number;
-        viewModel: any;
-        sender: HTMLElement | undefined;
-        postbackOptions: PostbackOptions;
-    };
-}
 declare module "utils/uri" {
     export function removeVirtualDirectoryFromUrl(url: string): string;
     export function addVirtualDirectoryToUrl(appRelativeUrl: string): string;
     export function addLeadingSlash(url: string): string;
     export function concatUrl(url1: string, url2: string): string;
 }
-declare module "shared-classes" {
-    export class DotvvmPostbackError {
-        reason: PostbackRejectionReason;
-        constructor(reason: PostbackRejectionReason);
-    }
-}
 declare module "postback/http" {
-    export function getJSON<T>(url: string, spaPlaceHolderUniqueId?: string, additionalHeaders?: {
+    export type WrappedResponse<T> = {
+        readonly result: T;
+        readonly response?: Response;
+    };
+    export function getJSON<T>(url: string, spaPlaceHolderUniqueId?: string, signal?: AbortSignal, additionalHeaders?: {
         [key: string]: string;
-    }): Promise<T>;
-    export function postJSON<T>(url: string, postData: any, additionalHeaders?: {
+    }): Promise<WrappedResponse<T>>;
+    export function postJSON<T>(url: string, postData: any, signal: AbortSignal | undefined, additionalHeaders?: {
         [key: string]: string;
-    }): Promise<T>;
-    export function fetchJson<T>(url: string, init: RequestInit): Promise<T>;
-    export function fetchCsrfToken(): Promise<string>;
+    }): Promise<WrappedResponse<T>>;
+    export function fetchJson<T>(url: string, init: RequestInit): Promise<WrappedResponse<T>>;
+    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" {
     export function backUpPostBackCounter(): number;
-    export function isPostBackStillActive(currentPostBackCounter: number): boolean;
-    export function resetPostBackCounter(): void;
-}
-declare module "postback/updater" {
-    export function getIsViewModelUpdating(): boolean;
-    export function cleanUpdatedControls(resultObject: any, updatedControls?: any): any;
-    export function restoreUpdatedControls(resultObject: any, updatedControls: any, applyBindingsOnEachControl: boolean): void;
-    export function updateViewModelAndControls(resultObject: any, clearViewModel: boolean): void;
-    export function patchViewModel(source: any, patch: any): any;
-    export function diffViewModel(source: any, modified: any): any;
 }
 declare module "utils/magic-navigator" {
     export function navigate(url: string): void;
 }
-declare module "postback/gate" {
-    export const isSpaNavigationRunning: KnockoutObservable<boolean>;
-    export function arePostbacksDisabled(): boolean;
-    export function disablePostbacks(): void;
-}
 declare module "postback/redirect" {
-    export function performRedirect(url: string, replace: boolean, allowSpa: boolean): Promise<DotvvmNavigationEventArgs> | undefined;
-    export function handleRedirect(resultObject: any, replace?: boolean): Promise<DotvvmNavigationEventArgs> | undefined;
+    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;
+    export function disablePostbacks(): void;
 }
-declare module "postback/postbackCore" {
-    export function getLastStartedPostbackId(): number;
-    export function postbackCore(options: PostbackOptions, path: string[], command: string, controlUniqueId: string, context: any, commandArgs?: any[]): Promise<PostbackCommitFunction>;
+declare module "validation/validators" {
+    import { DotvvmValidationContext } from "validation/common";
+    export type DotvvmValidator = {
+        isValid: (value: any, context: DotvvmValidationContext, property: KnockoutObservable<any>) => boolean;
+    };
+    export const required: DotvvmValidator;
+    export const regex: DotvvmValidator;
+    export const intRange: DotvvmValidator;
+    export const enforceClientFormat: DotvvmValidator;
+    export const range: DotvvmValidator;
+    export const notNull: DotvvmValidator;
+    export const emailAddress: DotvvmValidator;
+    type DotvvmValidatorSet = {
+        [name: string]: DotvvmValidator;
+    };
+    export const validators: DotvvmValidatorSet;
 }
 declare module "postback/internal-handlers" {
     export const isPostbackRunning: KnockoutObservable<boolean>;
     export const suppressOnDisabledElementHandler: DotvvmPostbackHandler;
     export const isPostBackRunningHandler: DotvvmPostbackHandler;
-    export const postbackHandlersStartedEventHandler: DotvvmPostbackHandler;
-    export const postbackHandlersCompletedEventHandler: DotvvmPostbackHandler;
     export const concurrencyDefault: (o: any) => {
         name: string;
         before: string[];
@@ -362,6 +534,7 @@ declare module "postback/internal-handlers" {
         before: string[];
         execute(next: () => Promise<PostbackCommitFunction>, options: PostbackOptions): Promise<PostbackCommitFunction>;
     };
+    export function isPostbackStillActive(options: PostbackOptions): boolean;
 }
 declare module "postback/handlers" {
     class ConfirmPostBackHandler implements DotvvmPostbackHandler {
@@ -381,52 +554,6 @@ declare module "postback/handlers" {
     export function getPostbackHandler(name: string): (options: any) => DotvvmPostbackHandler;
     export const defaultConcurrencyPostbackHandler: DotvvmPostbackHandler;
 }
-declare module "postback/postback" {
-    export function postBack(sender: HTMLElement, path: string[], command: string, controlUniqueId: string, context?: any, handlers?: ClientFriendlyPostbackHandlerConfiguration[], commandArgs?: any[]): 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 isPostbackHandler(obj: any): obj is DotvvmPostbackHandler;
-    export function sortHandlers(handlers: DotvvmPostbackHandler[]): DotvvmPostbackHandler[];
-}
-declare module "spa/navigation" {
-    export function navigateCore(url: string, handlePageNavigating?: (url: string) => void): Promise<DotvvmNavigationEventArgs>;
-}
-declare module "spa/spa" {
-    export const isSpaReady: KnockoutObservable<boolean>;
-    export function init(): void;
-    export function getSpaPlaceHoldersUniqueId(): string;
-    export function handleSpaNavigation(element: HTMLElement): Promise<DotvvmNavigationEventArgs>;
-    export function handleSpaNavigationCore(url: string | null): Promise<DotvvmNavigationEventArgs>;
-}
-declare module "validation/validators" {
-    import { DotvvmValidationContext } from "validation/common";
-    export type DotvvmValidator = {
-        isValid: (value: any, context: DotvvmValidationContext, property: KnockoutObservable<any>) => boolean;
-    };
-    export const required: DotvvmValidator;
-    export const regex: DotvvmValidator;
-    export const intRange: DotvvmValidator;
-    export const enforceClientFormat: DotvvmValidator;
-    export const range: DotvvmValidator;
-    export const notNull: DotvvmValidator;
-    export const emailAddress: DotvvmValidator;
-    type DotvvmValidatorSet = {
-        [name: string]: DotvvmValidator;
-    };
-    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 "validation/actions" {
     type DotvvmValidationActions = {
         [name: string]: (element: HTMLElement, errorMessages: string[], param: any) => void;
@@ -434,33 +561,57 @@ declare module "validation/actions" {
     export const elementActions: DotvvmValidationActions;
 }
 declare module "validation/validation" {
-    import { DotvvmValidator } from "validation/validators";
     import { ValidationError } from "validation/error";
     import { DotvvmEvent } from "events";
+    type DotvvmValidationErrorsChangedEventArgs = PostbackOptions & {
+        readonly allErrors: ValidationError[];
+    };
     export const events: {
-        validationErrorsChanged: DotvvmEvent<DotvvmEventArgs>;
+        validationErrorsChanged: DotvvmEvent<DotvvmValidationErrorsChangedEventArgs>;
     };
     export const globalValidationObject: {
         rules: {
-            [name: string]: DotvvmValidator;
+            [name: string]: import("validation/validators").DotvvmValidator;
         };
         errors: ValidationError[];
         events: {
-            validationErrorsChanged: DotvvmEvent<DotvvmEventArgs>;
+            validationErrorsChanged: DotvvmEvent<DotvvmValidationErrorsChangedEventArgs>;
         };
     };
     export function init(): void;
+    /**
+     * Adds validation errors from the server to the appropriate arrays
+     */
+    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[], 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, abortSignal?: AbortSignal): Promise<DotvvmAfterPostBackEventArgs>;
+    export function isPostbackHandler(obj: any): obj is DotvvmPostbackHandler;
+    export function sortHandlers(handlers: DotvvmPostbackHandler[]): DotvvmPostbackHandler[];
+}
+declare module "spa/navigation" {
+    export function navigateCore(url: string, options: PostbackOptions, handlePageNavigating: (url: string) => void): Promise<DotvvmNavigationEventArgs>;
+}
+declare module "spa/spa" {
+    export const isSpaReady: KnockoutObservable<boolean>;
+    export function init(): void;
+    export function getSpaPlaceHoldersUniqueId(): string;
+    export function handleSpaNavigation(element: HTMLElement): Promise<DotvvmNavigationEventArgs | undefined>;
+    export function handleSpaNavigationCore(url: string | null, sender?: HTMLElement, handlePageNavigating?: (url: string) => void): Promise<DotvvmNavigationEventArgs>;
 }
 declare module "binding-handlers/register" {
-    const _default_8: () => void;
-    export default _default_8;
+    const _default_12: () => void;
+    export default _default_12;
 }
 declare module "postback/staticCommand" {
-    export function staticCommandPostback_old(viewModelName: string, sender: HTMLElement, command: string, args: any[], callback?: (a: any) => void, errorCallback?: (errorInfo: {
-        xhr?: XMLHttpRequest;
-        error?: any;
-    }) => void): Promise<void>;
-    export function staticCommandPostback(sender: HTMLElement, command: string, args: any[]): 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;
@@ -468,20 +619,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: 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;
@@ -494,6 +632,65 @@ 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";
@@ -505,10 +702,18 @@ declare module "dotvvm-root" {
     import * as globalize from "DotVVM.Globalize";
     import { staticCommandPostback } from "postback/staticCommand";
     import { applyPostbackHandlers } from "postback/postback";
+    import { isSpaReady } from "spa/spa";
     import { buildRouteUrl, buildUrlSuffix } from "controls/routeLink";
     import * as fileUpload from "controls/fileUpload";
+    import { handleSpaNavigation } from "spa/spa";
+    import * as spaEvents from "spa/events";
     import * as api from "api/api";
     import * as eventHub from "api/eventHub";
+    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;
@@ -519,7 +724,6 @@ declare module "dotvvm-root" {
         fileUpload: {
             reportProgress: typeof fileUpload.reportProgress;
             showUploadDialog: typeof fileUpload.showUploadDialog;
-            createUploadId: typeof fileUpload.createUploadId;
         };
         api: {
             invoke: typeof api.invoke;
@@ -531,6 +735,7 @@ declare module "dotvvm-root" {
         };
         globalize: typeof globalize;
         postBackHandlers: DotvvmPostbackHandlerCollection;
+        postbackHandlers: DotvvmPostbackHandlerCollection;
         buildUrlSuffix: typeof buildUrlSuffix;
         buildRouteUrl: typeof buildRouteUrl;
         staticCommandPostback: typeof staticCommandPostback;
@@ -541,20 +746,25 @@ declare module "dotvvm-root" {
             };
             errors: import("validation/error").ValidationError[];
             events: {
-                validationErrorsChanged: events.DotvvmEvent<DotvvmEventArgs>;
+                validationErrorsChanged: events.DotvvmEvent<PostbackOptions & {
+                    readonly allErrors: import("validation/error").ValidationError[];
+                }>;
             };
         };
         postBack: typeof postBack;
         init: typeof init;
+        registerGlobalComponent: typeof viewModuleManager.registerGlobalComponent;
         isPostbackRunning: KnockoutObservable<boolean>;
-        events: typeof events;
+        events: Partial<typeof spaEvents> & typeof events;
         viewModels: {
             root: {
-                readonly viewModel: RootViewModel;
+                readonly viewModel: DeepKnockoutObservableObject<RootViewModel>;
             };
         };
+        readonly state: Readonly<RootViewModel>;
+        patchState(a: any): void;
         viewModelObservables: {
-            readonly root: KnockoutObservable<RootViewModel>;
+            readonly root: KnockoutObservable<DeepKnockoutObservableObject<RootViewModel>>;
         };
         serialization: {
             serialize: typeof serialize;
@@ -562,9 +772,39 @@ 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;
+            call: typeof viewModuleManager.callViewModuleCommand;
+            registerMany: typeof viewModuleManager.registerViewModules;
+        };
+        resourceLoader: {
+            notifyModuleLoaded: typeof notifyModuleLoaded;
+        };
+        log: {
+            logError: typeof logError;
+            logWarning: typeof logWarning;
+            logInfo: typeof logInfo;
+            logInfoVerbose: typeof logInfoVerbose;
+            logPostBackScriptError: typeof logPostBackScriptError;
+            level: "normal" | "verbose";
+        };
+        translations: any;
+        StateManager: typeof StateManager;
+        DotvvmEvent: typeof events.DotvvmEvent;
     };
     global {
-        const dotvvm: typeof dotvvmExports;
+        const dotvvm: typeof dotvvmExports & {
+            debug?: true;
+            isSpaReady?: typeof isSpaReady;
+            handleSpaNavigation?: typeof handleSpaNavigation;
+        };
         interface Window {
             dotvvm: typeof dotvvmExports;
         }
@@ -578,8 +818,11 @@ declare type DotvvmPostbackHandler = {
     after?: Array<string | DotvvmPostbackHandler>;
     before?: Array<string | DotvvmPostbackHandler>;
 };
-declare type PostbackRejectionReason = {
-    type: "handler";
+declare type DotvvmPostbackErrorLike = {
+    readonly reason: DotvvmPostbackErrorReason;
+};
+declare type DotvvmPostbackErrorReason = ({
+    type: 'handler';
     handlerName: string;
     message?: string;
 } | {
@@ -599,72 +842,96 @@ declare type PostbackRejectionReason = {
     response?: Response;
 } | {
     type: 'event';
-} & {
+} | {
+    type: 'validation';
+    responseObject: any;
+    response?: Response;
+} | {
+    type: 'abort';
+} | {
+    type: 'redirect';
+    responseObject: any;
+    response?: Response;
+}) & {
     options?: PostbackOptions;
 };
-interface AdditionalPostbackData {
-    [key: string]: any;
-    validationTargetPath?: string;
-}
+declare type PostbackCommandType = "postback" | "staticCommand" | "spaNavigation";
 declare type PostbackOptions = {
-    readonly additionalPostbackData: AdditionalPostbackData;
     readonly postbackId: number;
-    readonly sender?: HTMLElement;
+    readonly commandType: PostbackCommandType;
     readonly args: any[];
+    readonly sender?: HTMLElement;
     readonly viewModel?: any;
+    readonly knockoutContext?: any;
+    serverResponseObject?: any;
+    validationTargetPath?: string;
+    abortSignal?: AbortSignal;
 };
-declare type PostbackEventArgs = DotvvmEventArgs & {
-    readonly postbackClientId: number;
-    readonly sender?: Element;
-    readonly xhr?: XMLHttpRequest;
-    readonly serverResponseObject?: any;
-    readonly postbackOptions: PostbackOptions;
-};
-declare type DotvvmEventArgs = {
-    /** The global view model */
-    readonly viewModel?: any;
-};
-declare type DotvvmErrorEventArgs = {
-    readonly sender?: Element;
-    readonly serverResponseObject?: any;
-    readonly viewModel?: any;
-    readonly isSpaNavigationError?: true;
+declare type DotvvmErrorEventArgs = PostbackOptions & {
+    readonly response?: Response;
+    readonly error: DotvvmPostbackErrorLike;
     handled: boolean;
 };
-declare type DotvvmBeforePostBackEventArgs = PostbackEventArgs & {
+declare type DotvvmBeforePostBackEventArgs = PostbackOptions & {
     cancel: boolean;
 };
-declare type DotvvmAfterPostBackEventArgs = PostbackEventArgs & {
-    handled: boolean;
+declare type DotvvmAfterPostBackEventArgs = PostbackOptions & {
     /** Set to true in case the postback did not finish and it was cancelled by an event or a postback handler */
-    readonly wasInterrupted: boolean;
-    readonly serverResponseObject: any;
-    readonly commandResult: any;
+    readonly wasInterrupted?: boolean;
+    readonly commandResult?: any;
     readonly response?: Response;
-    /** In SPA mode, this promise is set when the result of a postback is a redirection. */
-    readonly redirectPromise?: Promise<DotvvmNavigationEventArgs>;
+    readonly error?: DotvvmPostbackErrorLike;
 };
-declare type DotvvmSpaNavigatingEventArgs = DotvvmEventArgs & {
-    /** When set to true by an event handler, it  */
-    cancel: boolean;
-    /** The url we are navigating to */
-    readonly newUrl: string;
+declare type DotvvmNavigationEventArgs = PostbackOptions & {
+    readonly url: string;
 };
-declare type DotvvmNavigationEventArgs = DotvvmEventArgs & {
-    readonly serverResponseObject: any;
-    readonly xhr?: XMLHttpRequest;
-    readonly isSpa?: true;
+declare type DotvvmSpaNavigatingEventArgs = DotvvmNavigationEventArgs & {
+    cancel: boolean;
 };
 declare type DotvvmSpaNavigatedEventArgs = DotvvmNavigationEventArgs & {
-    /** When error occurs, this is set to false and gives the event handlers a possibility to mark the error as handled */
-    isHandled: boolean;
+    readonly response?: Response;
 };
-declare type DotvvmRedirectEventArgs = DotvvmEventArgs & {
-    /** The url of the page we are navigating to */
-    readonly url: string;
+declare type DotvvmSpaNavigationFailedEventArgs = DotvvmNavigationEventArgs & {
+    readonly response?: Response;
+    readonly error?: DotvvmPostbackErrorLike;
+};
+declare type DotvvmRedirectEventArgs = DotvvmNavigationEventArgs & {
+    readonly response?: Response;
     /** Whether the new url should replace the current url in the browsing history */
     readonly replace: boolean;
 };
+declare type DotvvmPostbackHandlersStartedEventArgs = PostbackOptions & {};
+declare type DotvvmPostbackHandlersCompletedEventArgs = PostbackOptions & {};
+declare type DotvvmPostbackResponseReceivedEventArgs = PostbackOptions & {
+    readonly response: Response;
+};
+declare type DotvvmPostbackCommitInvokedEventArgs = PostbackOptions & {
+    readonly response: Response;
+};
+declare type DotvvmPostbackViewModelUpdatedEventArgs = PostbackOptions & {
+    readonly response: Response;
+};
+declare type DotvvmPostbackRejectedEventArgs = PostbackOptions & {
+    readonly error: DotvvmPostbackErrorLike;
+};
+declare type DotvvmStaticCommandMethodEventArgs = PostbackOptions & {
+    readonly methodId: string;
+    readonly methodArgs: any[];
+};
+declare type DotvvmStaticCommandMethodInvokingEventArgs = DotvvmStaticCommandMethodEventArgs & {};
+declare type DotvvmStaticCommandMethodInvokedEventArgs = DotvvmStaticCommandMethodEventArgs & {
+    readonly result: any;
+    readonly response?: Response;
+};
+declare type DotvvmStaticCommandMethodFailedEventArgs = DotvvmStaticCommandMethodEventArgs & {
+    readonly result?: any;
+    readonly response?: Response;
+    readonly error: DotvvmPostbackErrorLike;
+};
+declare type DotvvmInitEventArgs = {
+    readonly viewModel: any;
+};
+declare type DotvvmInitCompletedEventArgs = {};
 interface DotvvmViewModelInfo {
     viewModel?: any;
     viewModelCacheId?: string;
@@ -672,6 +939,7 @@ interface DotvvmViewModelInfo {
     renderedResources?: string[];
     url?: string;
     virtualDirectory?: string;
+    typeMetadata: TypeMap;
 }
 interface DotvvmViewModels {
     [name: string]: DotvvmViewModelInfo;
@@ -680,11 +948,17 @@ interface DotvvmViewModels {
 interface DotvvmPostbackHandlerCollection {
     [name: string]: ((options: any) => DotvvmPostbackHandler);
 }
-declare type DotvvmStaticCommandResponse = {
+declare type DotvvmStaticCommandResponse<T = any> = {
     result: any;
+    customData: {
+        [key: string]: any;
+    };
+    typeMetadata?: TypeMap;
 } | {
     action: "redirect";
     url: string;
+    replace?: boolean;
+    allowSpa?: boolean;
 };
 declare type DotvvmPostBackHandlerConfiguration = {
     name: string;
@@ -701,6 +975,135 @@ declare type ValidationRuleTable = {
         [property: string]: [PropertyValidationRuleInfo];
     };
 };
+declare type StateUpdate<TViewModel> = (initial: DeepReadonly<TViewModel>) => DeepReadonly<TViewModel>;
+declare type UpdateDispatcher<TViewModel> = (update: StateUpdate<TViewModel>) => void;
+/** Knockout observable, including all child object and arrays */
+declare type DeepKnockoutObservable<T> = T extends (infer R)[] ? DeepKnockoutObservableArray<R> : T extends object ? KnockoutObservable<DeepKnockoutObservableObject<T>> : KnockoutObservable<T>;
+declare type DeepKnockoutObservableArray<T> = KnockoutObservableArray<DeepKnockoutObservable<T>>;
+declare type DeepKnockoutObservableObject<T> = {
+    readonly [P in keyof T]: DeepKnockoutObservable<T[P]>;
+};
+/** Partial<T>, but including all child objects  */
+declare type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/** Readonly<T>, but including all child objects and arrays  */
+declare type DeepReadonly<T> = T extends TypeDefinition ? T : T extends (infer R)[] ? readonly DeepReadonly<R>[] : T extends object ? {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+} : T;
+/** Knockout observable that is found in the DotVVM ViewModel - all nested objects and arrays are also observable + it has some helper functions (state, patchState, ...) */
+declare type DotvvmObservable<T> = DeepKnockoutObservable<T> & {
+    /** A property, returns latest state from dotvvm.state. It does not contain any knockout observable and does not have any propagation delay, as the value in the observable */
+    readonly state: DeepReadonly<T>;
+    /** Sets new state directly into the dotvvm.state.
+     * Note that the value arrives into the observable itself asynchronously, so there might be slight delay */
+    readonly setState: (newState: DeepReadonly<T>) => void;
+    /** Patches the current state and sets it into dotvvm.state.
+     * Compared to setState, when property does not exist in the patch parameter, the old value from state is used.
+     * Note that the value arrives into the observable itself asynchronously, so there might be slight delay
+     * @example observable.patchState({ Prop2: 0 }) // Only must be specified, although Prop1 also exists and is required  */
+    readonly patchState: (patch: DeepReadonly<DeepPartial<T>>) => void;
+    /** Dispatches update of the state.
+     * Note that the value arrives into the observable itself asynchronously, so there might be slight delay
+     * @example observable.updater(state => [ ...state, newElement ]) // This appends an element to an (observable) array
+     * @example observable.updater(state => state + 1) // Increments the value by one
+     * @example observable.updater(state => ({ ...state, MyProperty: state.MyProperty + 1 })) // Increments the property MyProperty by one
+     */
+    readonly updater: UpdateDispatcher<T>;
+};
 declare type RootViewModel = {
-    $csrfToken?: string | KnockoutObservable<string>;
+    $type: string;
+    $csrfToken?: string;
+    [name: string]: any;
+};
+declare type TypeMap = {
+    [typeId: string]: TypeMetadata;
+};
+declare type ObjectTypeMetadata = {
+    type: "object";
+    properties: {
+        [prop: string]: PropertyMetadata;
+    };
+};
+declare type EnumTypeMetadata = {
+    type: "enum";
+    values: {
+        [name: string]: number;
+    };
+    isFlags?: boolean;
+};
+declare type TypeMetadata = ObjectTypeMetadata | EnumTypeMetadata;
+declare type PropertyMetadata = {
+    type: TypeDefinition;
+    post?: "always" | "pathOnly" | "no";
+    update?: "always" | "firstRequest" | "no";
+    validationRules?: PropertyValidationRuleInfo[];
+    clientExtenders?: ClientExtenderInfo[];
+};
+declare type TypeDefinition = string | {
+    readonly type: "nullable";
+    readonly inner: TypeDefinition;
+} | {
+    readonly type: "dynamic";
+} | TypeDefinition[];
+declare type ClientExtenderInfo = {
+    name: string;
+    parameter: any;
+};
+declare type CoerceErrorType = {
+    isError: true;
+    wasCoerced: false;
+    message: string;
+    path: string;
+    prependPathFragment(fragment: string): void;
+    value: never;
+};
+declare type CoerceResult = CoerceErrorType | {
+    value: any;
+    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.0-preview01",
+  "version": "4.0.7",
   "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"
   }