@docsvision/webclient 5.17.0-beta.9 → 5.17.1-beta.1

package/Platform/FolderTypeItems.d.ts

@@ -0,0 +1,25 @@
+import { $FolderTypesController } from '@docsvision/webclient/Generated/DocsVision.WebClient.Controllers';
+import { IFolderTypeItemsState, FolderTypeItemsImpl, FolderTypeItem } from '@docsvision/webclient/Platform/FolderTypeItemsImpl';
+import { InputBasedControlParams, InputBasedControl } from '@docsvision/webclient/System/InputBasedControl';
+import { $CardInfo, $LayoutInfo } from '@docsvision/webclient/System/LayoutServices';
+import { BasicEvent } from '@docsvision/webclient/System/BasicEvent';
+import { $LabelWidth } from '@docsvision/webclient/System/$LabelWidth';
+import { Optional } from '@docsvision/web/core/services';
+export declare class FolderTypeItemsParams extends InputBasedControlParams<string> {
+    /** Событие изменения выбранного типа */
+    typeChanged?: BasicEvent<FolderTypeItem>;
+    /** Сервисы */
+    services?: $LayoutInfo & $CardInfo & Optional<$LabelWidth> & $FolderTypesController;
+}
+/**
+ * Класс элемента управления Выбор представления папки.
+ */
+export declare class FolderTypeItems extends InputBasedControl<string, FolderTypeItemsParams, IFolderTypeItemsState> {
+    protected createParams(): FolderTypeItemsParams;
+    protected createImpl(): FolderTypeItemsImpl;
+    protected getServices(): any;
+    get typeValue(): FolderTypeItem;
+    set typeValue(value: FolderTypeItem);
+    open(): void;
+    close(): void;
+}

package/Platform/FolderTypeItems.stories.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FolderTypeItems } from '@docsvision/webclient/Platform/FolderTypeItems';
+declare const _default: {
+    title: string;
+    component: typeof FolderTypeItems;
+};
+export default _default;
+export declare const Edit: () => JSX.Element;
+export declare const View: () => JSX.Element;

package/Platform/FolderTypeItemsImpl.d.ts

@@ -0,0 +1,52 @@
+import { InputBasedControlState, InputBasedControlImpl } from '@docsvision/webclient/System/InputBasedControlImpl';
+import React from 'react';
+import { FolderTypeItemsParams } from '@docsvision/webclient/Platform/FolderTypeItems';
+import { LoadingState } from '@docsvision/webclient/System/LoadingState';
+import { ModalHost } from '@docsvision/webclient/Helpers/ModalHost';
+import { Tree } from '@docsvision/webclient/Helpers/Tree/Tree';
+import { ITreeNodeData } from '@docsvision/webclient/Helpers/Tree/Data/ClientModels/ITreeNodeData';
+import { TreeNode } from '@docsvision/webclient/Helpers/Tree/Data/ClientModels/TreeNode';
+/** @internal */
+export declare type FolderTypeItem = {
+    defaultViewId: string;
+    folderTypeId: string;
+    highlightUnreadCards: boolean;
+    name: string;
+    parentFolderTypeId: string;
+    children: Array<FolderTypeItem>;
+};
+/** @internal */
+export declare type FolderTypeTreeNode = FolderTypeItem & ITreeNodeData;
+/** @internal */
+export interface IFolderTypeItemsState extends FolderTypeItemsParams, InputBasedControlState<string> {
+    dialog: ModalHost;
+    selected: FolderTypeItem;
+    accepted: FolderTypeItem;
+    loading: LoadingState;
+    items: Array<FolderTypeTreeNode>;
+    types: Array<FolderTypeItem>;
+    services: any;
+}
+export interface FolderTypeItemsState extends IFolderTypeItemsState {
+}
+/** @internal */
+export declare type FolderTypeItemsImplState = IFolderTypeItemsState;
+/** @internal */
+export declare class FolderTypeItemsImpl extends InputBasedControlImpl<string, FolderTypeItemsParams, IFolderTypeItemsState> {
+    constructor(props: any, state: any);
+    protected getTextValue(): string;
+    protected getCssClass(): string;
+    protected renderInto(props: FolderTypeItemsParams, container: HTMLElement): void;
+    protected onInputChange(ev: React.ChangeEvent): void;
+    protected onSelectItem(sender: Tree, item: TreeNode): void;
+    private filterTreeNodeProperty;
+    protected onAcceptItem(): void;
+    protected loadTypeItems(): Promise<void>;
+    private prepareTreeItems;
+    protected attachTree(tree: Tree): void;
+    protected renderInput(): React.ReactNode;
+    protected renderDialog(): JSX.Element;
+    protected createDialog(): void;
+    openDialog(): Promise<void>;
+    closeDialog(): void;
+}

package/Platform/FolderViewItems.d.ts

@@ -0,0 +1,26 @@
+import { $CardController } from '@docsvision/webclient/Generated/DocsVision.WebClient.Controllers';
+import { IFolderViewItemsState, FolderViewItemsImpl, FolderViewVariant } from '@docsvision/webclient/Platform/FolderViewItemsImpl';
+import { InputBasedControlParams, InputBasedControl } from '@docsvision/webclient/System/InputBasedControl';
+import { $CardInfo, $LayoutInfo } from '@docsvision/webclient/System/LayoutServices';
+import { $LabelWidth } from '@docsvision/webclient/System/$LabelWidth';
+import { Optional } from '@docsvision/web/core/services';
+export declare class FolderViewItemsParams extends InputBasedControlParams<string> {
+    /** Id папки */
+    folderId?: string;
+    /** Id типа папки */
+    folderTypeId?: string;
+    /** Сервисы */
+    services?: $LayoutInfo & $CardInfo & Optional<$LabelWidth> & $CardController;
+}
+/**
+ * Класс элемента управления Выбор представления папки.
+ */
+export declare class FolderViewItems extends InputBasedControl<string, FolderViewItemsParams, IFolderViewItemsState> {
+    protected createParams(): FolderViewItemsParams;
+    protected createImpl(): FolderViewItemsImpl;
+    protected getServices(): any;
+    get viewValue(): FolderViewVariant;
+    set viewValue(value: FolderViewVariant);
+    setDefaultValue(): void;
+    getValueById(id: string): Promise<FolderViewVariant>;
+}

package/Platform/FolderViewItems.stories.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FolderViewItems } from '@docsvision/webclient/Platform/FolderViewItems';
+declare const _default: {
+    title: string;
+    component: typeof FolderViewItems;
+};
+export default _default;
+export declare const Edit: () => JSX.Element;
+export declare const View: () => JSX.Element;

package/Platform/FolderViewItemsImpl.d.ts

@@ -0,0 +1,338 @@
+import { InputBasedControlState, InputBasedControlImpl } from '@docsvision/webclient/System/InputBasedControlImpl';
+import React from 'react';
+import { Typeahead } from '@docsvision/webclient/Helpers/Typeahead/Typeahead';
+import { ITypeaheadVariant } from '@docsvision/webclient/Helpers/Typeahead/Models/ITypeaheadVariant';
+import { SimpleEvent } from '@docsvision/webclient/System/SimpleEvent';
+import { ITypeaheadSearchResult } from '@docsvision/webclient/Helpers/Typeahead/Models/ITypeaheadSearchResult';
+import { FolderViewItemsParams } from '@docsvision/webclient/Platform/FolderViewItems';
+/** @internal */
+export declare type FolderViewVariant = ITypeaheadVariant & {
+    isDefault: boolean;
+};
+/** @internal */
+export declare type FolderViewSearchResult = {
+    items: Array<FolderViewVariant>;
+    hasMore: boolean;
+};
+/** @internal */
+export interface IFolderViewItemsState extends FolderViewItemsParams, InputBasedControlState<string> {
+    typeahead: Typeahead;
+    inputKeyDown: SimpleEvent<React.KeyboardEvent>;
+    selected: FolderViewVariant;
+    services: any;
+}
+export interface FolderViewItemsState extends IFolderViewItemsState {
+}
+/** @internal */
+export declare type FolderViewItemsImplState = IFolderViewItemsState;
+/** @internal */
+export declare class FolderViewItemsImpl extends InputBasedControlImpl<string, FolderViewItemsParams, IFolderViewItemsState> {
+    constructor(props: any, state: any);
+    protected getTextValue(): string;
+    protected getCssClass(): string;
+    protected renderInto(props: FolderViewItemsParams, container: HTMLElement): void;
+    protected onInputChange(ev: React.ChangeEvent): void;
+    protected getInputProps(): {
+        readOnly: boolean;
+        ref?: React.LegacyRef<HTMLInputElement>;
+        key?: string | number;
+        accept?: string;
+        alt?: string;
+        autoComplete?: string;
+        autoFocus?: boolean;
+        capture?: string | boolean;
+        checked?: boolean;
+        crossOrigin?: string;
+        disabled?: boolean;
+        enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+        form?: string;
+        formAction?: string;
+        formEncType?: string;
+        formMethod?: string;
+        formNoValidate?: boolean;
+        formTarget?: string;
+        height?: string | number;
+        list?: string;
+        max?: string | number;
+        maxLength?: number;
+        min?: string | number;
+        minLength?: number;
+        multiple?: boolean;
+        name?: string;
+        pattern?: string;
+        placeholder?: string;
+        required?: boolean;
+        size?: number;
+        src?: string;
+        step?: string | number;
+        type?: string;
+        value?: string | number | readonly string[];
+        width?: string | number;
+        onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+        defaultChecked?: boolean;
+        defaultValue?: string | number | readonly string[];
+        suppressContentEditableWarning?: boolean;
+        suppressHydrationWarning?: boolean;
+        accessKey?: string;
+        className?: string;
+        contentEditable?: boolean | "inherit" | "true" | "false";
+        contextMenu?: string;
+        dir?: string;
+        draggable?: boolean | "true" | "false";
+        hidden?: boolean;
+        id?: string;
+        lang?: string;
+        slot?: string;
+        spellCheck?: boolean | "true" | "false";
+        style?: React.CSSProperties;
+        tabIndex?: number;
+        title?: string;
+        translate?: "no" | "yes";
+        radioGroup?: string;
+        role?: string;
+        about?: string;
+        datatype?: string;
+        inlist?: any;
+        prefix?: string;
+        property?: string;
+        resource?: string;
+        typeof?: string;
+        vocab?: string;
+        autoCapitalize?: string;
+        autoCorrect?: string;
+        autoSave?: string;
+        color?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemID?: string;
+        itemRef?: string;
+        results?: number;
+        security?: string;
+        unselectable?: "on" | "off";
+        inputMode?: "none" | "text" | "url" | "tel" | "email" | "numeric" | "decimal" | "search";
+        is?: string;
+        'aria-activedescendant'?: string;
+        'aria-atomic'?: boolean | "true" | "false";
+        'aria-autocomplete'?: "none" | "list" | "inline" | "both";
+        'aria-busy'?: boolean | "true" | "false";
+        'aria-checked'?: boolean | "true" | "false" | "mixed";
+        'aria-colcount'?: number;
+        'aria-colindex'?: number;
+        'aria-colspan'?: number;
+        'aria-controls'?: string;
+        'aria-current'?: boolean | "time" | "true" | "false" | "step" | "page" | "location" | "date";
+        'aria-describedby'?: string;
+        'aria-details'?: string;
+        'aria-disabled'?: boolean | "true" | "false";
+        'aria-dropeffect'?: "copy" | "none" | "link" | "execute" | "move" | "popup";
+        'aria-errormessage'?: string;
+        'aria-expanded'?: boolean | "true" | "false";
+        'aria-flowto'?: string;
+        'aria-grabbed'?: boolean | "true" | "false";
+        'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "listbox" | "tree" | "grid";
+        'aria-hidden'?: boolean | "true" | "false";
+        'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
+        'aria-keyshortcuts'?: string;
+        'aria-label'?: string;
+        'aria-labelledby'?: string;
+        'aria-level'?: number;
+        'aria-live'?: "off" | "assertive" | "polite";
+        'aria-modal'?: boolean | "true" | "false";
+        'aria-multiline'?: boolean | "true" | "false";
+        'aria-multiselectable'?: boolean | "true" | "false";
+        'aria-orientation'?: "horizontal" | "vertical";
+        'aria-owns'?: string;
+        'aria-placeholder'?: string;
+        'aria-posinset'?: number;
+        'aria-pressed'?: boolean | "true" | "false" | "mixed";
+        'aria-readonly'?: boolean | "true" | "false";
+        'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+        'aria-required'?: boolean | "true" | "false";
+        'aria-roledescription'?: string;
+        'aria-rowcount'?: number;
+        'aria-rowindex'?: number;
+        'aria-rowspan'?: number;
+        'aria-selected'?: boolean | "true" | "false";
+        'aria-setsize'?: number;
+        'aria-sort'?: "none" | "ascending" | "descending" | "other";
+        'aria-valuemax'?: number;
+        'aria-valuemin'?: number;
+        'aria-valuenow'?: number;
+        'aria-valuetext'?: string;
+        children?: React.ReactNode;
+        dangerouslySetInnerHTML?: {
+            __html: string;
+        };
+        onCopy?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onCopyCapture?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onCut?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onCutCapture?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onPaste?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onPasteCapture?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
+        onCompositionEnd?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onCompositionEndCapture?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onCompositionStart?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onCompositionStartCapture?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onCompositionUpdate?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onCompositionUpdateCapture?: (event: React.CompositionEvent<HTMLInputElement>) => void;
+        onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+        onFocusCapture?: (event: React.FocusEvent<HTMLInputElement>) => void;
+        onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+        onBlurCapture?: (event: React.FocusEvent<HTMLInputElement>) => void;
+        onChangeCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onBeforeInput?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onBeforeInputCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onInput?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onInputCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onReset?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onResetCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onSubmit?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onSubmitCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onInvalid?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onInvalidCapture?: (event: React.FormEvent<HTMLInputElement>) => void;
+        onLoad?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onError?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onErrorCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onKeyDownCapture?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onKeyPress?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onKeyPressCapture?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onKeyUpCapture?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+        onAbort?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onAbortCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onCanPlay?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onCanPlayCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onCanPlayThrough?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onCanPlayThroughCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onDurationChange?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onDurationChangeCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEmptied?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEmptiedCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEncrypted?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEncryptedCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEnded?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onEndedCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadedData?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadedDataCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadedMetadata?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadedMetadataCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadStart?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onLoadStartCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPause?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPauseCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPlay?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPlayCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPlaying?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onPlayingCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onProgress?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onProgressCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onRateChange?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onRateChangeCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSeeked?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSeekedCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSeeking?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSeekingCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onStalled?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onStalledCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSuspend?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSuspendCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onTimeUpdate?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onTimeUpdateCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onVolumeChange?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onVolumeChangeCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onWaiting?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onWaitingCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onAuxClick?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onAuxClickCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onClick?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onClickCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onContextMenu?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onContextMenuCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onDoubleClick?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onDoubleClickCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onDrag?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragEnd?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragEndCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragEnter?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragEnterCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragExit?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragExitCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragLeave?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragLeaveCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragOver?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragOverCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragStart?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDragStartCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDrop?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onDropCapture?: (event: React.DragEvent<HTMLInputElement>) => void;
+        onMouseDown?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseDownCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseEnter?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseLeave?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseMove?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseMoveCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseOut?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseOutCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseOver?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseOverCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseUp?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onMouseUpCapture?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+        onSelect?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onSelectCapture?: (event: React.SyntheticEvent<HTMLInputElement, Event>) => void;
+        onTouchCancel?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchCancelCapture?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchEnd?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchEndCapture?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchMove?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchMoveCapture?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchStart?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onTouchStartCapture?: (event: React.TouchEvent<HTMLInputElement>) => void;
+        onPointerDown?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerDownCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerMove?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerMoveCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerUp?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerUpCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerCancel?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerCancelCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerEnter?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerEnterCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerLeave?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerLeaveCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerOver?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerOverCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerOut?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onPointerOutCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onGotPointerCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onGotPointerCaptureCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onLostPointerCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onLostPointerCaptureCapture?: (event: React.PointerEvent<HTMLInputElement>) => void;
+        onScroll?: (event: React.UIEvent<HTMLInputElement, UIEvent>) => void;
+        onScrollCapture?: (event: React.UIEvent<HTMLInputElement, UIEvent>) => void;
+        onWheel?: (event: React.WheelEvent<HTMLInputElement>) => void;
+        onWheelCapture?: (event: React.WheelEvent<HTMLInputElement>) => void;
+        onAnimationStart?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onAnimationStartCapture?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onAnimationEnd?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onAnimationEndCapture?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onAnimationIteration?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onAnimationIterationCapture?: (event: React.AnimationEvent<HTMLInputElement>) => void;
+        onTransitionEnd?: (event: React.TransitionEvent<HTMLInputElement>) => void;
+        onTransitionEndCapture?: (event: React.TransitionEvent<HTMLInputElement>) => void;
+        css?: 
+import("@emotion/core").InterpolationWithTheme<any>;
+    };
+    protected attachTypeahead(typeahead: Typeahead): void;
+    protected onTypeaheadSelected(variant: FolderViewVariant): Promise<void>;
+    protected processTypeaheadSelected(variant: FolderViewVariant): Promise<void>;
+    protected findItems(): Promise<ITypeaheadSearchResult>;
+    setDefault(): Promise<void>;
+    getById(id: string): Promise<FolderViewVariant>;
+    protected renderTypeahead(): JSX.Element;
+    protected renderTypeaheadInput(): JSX.Element;
+    protected renderInputWithPlaceholder(): JSX.Element;
+}

package/Platform/FolderWebFrameRouteHandler.d.ts

@@ -0,0 +1,21 @@
+import { IRouteHandler } from "@docsvision/webclient/System/IRouteHandler";
+import { RouteHandleResult } from "@docsvision/webclient/System/RouteHandleResult";
+import { RouteType } from "@docsvision/webclient/System/RouteType";
+import { IFolderPageRouteData } from '@docsvision/webclient/Platform/IFolderPageRouteData';
+import { $ApplicationSettings, $IsIE } from "@docsvision/webclient/StandardServices";
+import { $LayoutBackground } from "@docsvision/webclient/System/$LayoutBackground";
+import { $LayoutManager } from "@docsvision/webclient/System/$LayoutManager";
+/** @internal */
+export declare class FolderWebFrameRouteHandler implements IRouteHandler<IFolderPageRouteData> {
+    private services;
+    name: string;
+    private layoutContainerName;
+    private webFrameContentBackgroundClass;
+    private webFrameContentName;
+    constructor(services: $ApplicationSettings & $IsIE & $LayoutBackground & $LayoutManager);
+    private get useNewGrid();
+    private routeTypeCheck;
+    private filterClasses;
+    mountRoute(data: IFolderPageRouteData, routeType: RouteType): Promise<RouteHandleResult>;
+    unmountRoute(data: IFolderPageRouteData, routeType: RouteType): Promise<void>;
+}

package/Platform/FormatFileVersion.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { GenModels } from '@docsvision/webclient/Generated/DocsVision.WebClient.Models';
+export declare const formatFileVersion: (version: GenModels.FileCardVersionModel) => JSX.Element;

package/Platform/FormatNumberToCulture.d.ts

@@ -0,0 +1,8 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+export interface INumberFormatInfo {
+    numberGroupSeparator: string;
+    numberGroupSizes: number[];
+    numberDecimalDigits: number;
+    numberDecimalSeparator: string;
+}
+export declare function formatNumberToCulture(value: number, type: GenModels.ColumnType, numberFormatInfo: INumberFormatInfo): string;

package/Platform/FormatNumberToCultureString.d.ts

@@ -0,0 +1,8 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+export interface INumberFormatInfo {
+    numberGroupSeparator: string;
+    numberGroupSizes: number[];
+    numberDecimalDigits: number;
+    numberDecimalSeparator: string;
+}
+export declare function formatNumberToCultureString(value: number, type: GenModels.ColumnType, numberFormatInfo: INumberFormatInfo): string;

package/Platform/FormatSearchQueryParams.d.ts

@@ -0,0 +1,2 @@
+import { IDiagramChosenQueryParams } from "@docsvision/webclient/Platform/IDiagramModels";
+export declare function formatSearchQueryParams(queryParams: any, queryParamsChosen: IDiagramChosenQueryParams): any;

package/Platform/GetArrayWidth.d.ts

@@ -0,0 +1,2 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+export declare function getArrayWidth(gridUserSettingsData: GenModels.GridUserSettingsData, columns: GenModels.ViewColumnModel[]): any[];

package/Platform/GetDiagramType.d.ts

@@ -0,0 +1,6 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+export interface IDiagramTypeOptions {
+    type?: string;
+    stacked?: boolean;
+}
+export declare const getDiagramType: (diagramType: GenModels.DiagramType) => IDiagramTypeOptions;

package/Platform/GetFileExtension.d.ts

@@ -0,0 +1 @@
+export declare function getFileExtension(name: string): string;

package/Platform/GetFlagEntry.d.ts

@@ -0,0 +1,3 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+import { AccessListRow } from "@docsvision/webclient/Platform/AccessListRow";
+export declare function getFlagEntry(row: AccessListRow, flagInfo: GenModels.AccessMaskFlagInfo): GenModels.AccessControlEntry;

package/Platform/GetFlagState.d.ts

@@ -0,0 +1,3 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+import { AccessListRow } from "@docsvision/webclient/Platform/AccessListRow";
+export declare function getFlagState(row: AccessListRow, flagInfo: GenModels.AccessMaskFlagInfo, scheme: GenModels.AccessMaskScheme): any;

package/Platform/GetInheritanceMode.d.ts

@@ -0,0 +1,4 @@
+export declare function getInheritanceMode(flags: number, modes: Array<{
+    flags: number;
+    name: string;
+}>): string;

package/Platform/GetSortByRequest.d.ts

@@ -0,0 +1,3 @@
+import { GenModels } from '@docsvision/webclient/Generated/DocsVision.WebClient.Models';
+import { SortDirection } from '@docsvision/web/components/table/plugins/sort';
+export declare function getSortByRequest(request: GenModels.QueryViewRequest, columnAlias: string, sortDirection: SortDirection): GenModels.QueryViewRequest;

package/Platform/GetWebFrameHeaderContainerChildControls.d.ts

@@ -0,0 +1,11 @@
+import { LayoutControl } from "@docsvision/webclient/System/BaseControl";
+export declare enum WebFrameHeaderContentAvailableControls {
+    CustomButton = "CustomButton",
+    TextBox = "TextBox",
+    Number = "Number",
+    Url = "Url",
+    Dropdown = "Dropdown",
+    Label = "Label",
+    RadioGroup = "RadioGroup"
+}
+export declare function getWebFrameHeaderContainerChildControls(controls?: LayoutControl[]): LayoutControl[];

package/Platform/GridFilterItem.d.ts

@@ -0,0 +1,54 @@
+import { GenModels } from "@docsvision/webclient/Generated/DocsVision.WebClient.Models";
+import { GridFilterItemImpl, IGridFilterItemState } from "@docsvision/webclient/Platform/GridFilterItemImpl";
+import { IGridFilterItemControl } from "@docsvision/webclient/Platform/IGridFilterItemControl";
+import { Panel } from "@docsvision/webclient/Platform/Panel";
+import { $DeviceType } from "@docsvision/webclient/StandardServices";
+import { BaseControlParams } from "@docsvision/webclient/System/BaseControl";
+/**
+ * Содержит публичные свойства элемента управления [GridFilterItem]{@link GridFilterItem}.
+ */
+export declare class GridFilterItemParams extends BaseControlParams {
+    /** Стандартный CSS класс со стилями элемента управления. */
+    standardCssClass?: string;
+    /** Включен ли параметр в поиск или нет. */
+    filterItemEnabled?: boolean;
+    /** Имя столбца фильтрации. */
+    columnName?: string;
+    /** Заголовок фильтра. */
+    header?: string;
+    /** Введенное значение фильтра. */
+    filterItemValue?: string;
+    /** Тип данных столбца. */
+    columnType?: GenModels.ColumnType;
+    /** Состояние панели. */
+    expanded?: boolean;
+    services?: $DeviceType;
+}
+/**
+ * Класс элемента управления для отображения значения фильтра в виде раскрывающейся панели.
+ */
+export declare class GridFilterItem extends Panel<GridFilterItemParams, IGridFilterItemState> implements IGridFilterItemControl {
+    get isGridFilterItem(): boolean;
+    /** @internal */
+    init(): void;
+    /** Веденое пользователем значение параметра. */
+    get filterItemValues(): string[];
+    set filterItemValues(val: string[]);
+    /** Имя параметра, которое будет передано в поисковый запрос. */
+    get columnName(): string;
+    /** Содержит false если ползователь исключил условие из поиска. */
+    get filterItemEnabled(): boolean;
+    set filterItemEnabled(val: boolean);
+    /** Тип данных столбца */
+    get columnType(): GenModels.ColumnType;
+    /** Значение дочернего элемента управления, отвечающего за ввод значения фильтра. */
+    get controlValue(): unknown;
+    set controlValue(val: unknown);
+    /** Состояние панели */
+    get filterItemExpanded(): boolean;
+    set filterItemExpanded(val: boolean);
+    /** @internal */
+    protected createParams(): GridFilterItemParams;
+    /** @internal */
+    protected createImpl(): GridFilterItemImpl;
+}