diff --git a/packages/qgrid-core/src/body/body.host.d.ts b/packages/qgrid-core/src/body/body.host.d.ts
index 611e62096..95e28a746 100644
--- a/packages/qgrid-core/src/body/body.host.d.ts
+++ b/packages/qgrid-core/src/body/body.host.d.ts
@@ -3,8 +3,8 @@ import { GridPlugin } from '../plugin/grid.plugin';
 export declare class BodyHost {
   constructor(plugin: GridPlugin);
 
-  scroll(e: { scrollLeft: number; scrollTop: number });
-  wheel(e: WheelEvent);
+  scroll(e: { scrollLeft: number; scrollTop: number }): void;
+  wheel(e: WheelEvent): void;
 
-  mouseLeave(e: MouseEvent);
+  mouseLeave(e: MouseEvent): void;
 }
diff --git a/packages/qgrid-core/src/column-list/column.list.host.d.ts b/packages/qgrid-core/src/column-list/column.list.host.d.ts
index 758f9af1b..cf357d962 100644
--- a/packages/qgrid-core/src/column-list/column.list.host.d.ts
+++ b/packages/qgrid-core/src/column-list/column.list.host.d.ts
@@ -13,5 +13,5 @@ export declare class ColumnListHost {
   register(column: ColumnModel): void;
   generateKey(source: any): string;
   extract(key: string, type: string): ColumnModel;
-  delete(key: string);
+  delete(key: string): void;
 }
diff --git a/packages/qgrid-core/src/column/column.service.d.ts b/packages/qgrid-core/src/column/column.service.d.ts
index c9ca197e1..b6c675627 100644
--- a/packages/qgrid-core/src/column/column.service.d.ts
+++ b/packages/qgrid-core/src/column/column.service.d.ts
@@ -13,4 +13,4 @@ export declare function lineView(columnRows: ColumnView[]): string;
 export declare function widthFactory(table: Table, form: Map<string, any>): number;
 
 export declare function flattenColumns(columns: ColumnModel[]): ColumnModel[];
-export declare function findLine(columns: ColumnModel[], key: string): { columns: ColumnModel[]; index: number } | null;
+export declare function findLine(columns: ColumnModel[], key: string): any;
diff --git a/packages/qgrid-core/src/focus/focus.service.d.ts b/packages/qgrid-core/src/focus/focus.service.d.ts
index b0611ce80..96831411c 100644
--- a/packages/qgrid-core/src/focus/focus.service.d.ts
+++ b/packages/qgrid-core/src/focus/focus.service.d.ts
@@ -4,7 +4,7 @@ import { GridPlugin } from '../plugin/grid.plugin';
 export declare class FocusService {
   constructor(model: Model);
 
-  activate(rowIndex?: number, columnIndex?: number);
+  activate(rowIndex?: number, columnIndex?: number): void;
 }
 
 export declare class FocusAfterRenderService {
diff --git a/packages/qgrid-core/src/head/head.host.d.ts b/packages/qgrid-core/src/head/head.host.d.ts
index 6bd2b635e..f765adf98 100644
--- a/packages/qgrid-core/src/head/head.host.d.ts
+++ b/packages/qgrid-core/src/head/head.host.d.ts
@@ -3,6 +3,6 @@ import { GridPlugin } from '../plugin/grid.plugin';
 export declare class HeadHost {
   constructor(plugin: GridPlugin);
 
-  mouseMove(e: MouseEvent);
-  mouseLeave(e: MouseEvent);
+  mouseMove(e: MouseEvent): void;
+  mouseLeave(e: MouseEvent): void;
 }
diff --git a/packages/qgrid-core/src/infrastructure/cache.d.ts b/packages/qgrid-core/src/infrastructure/cache.d.ts
index 7778d6273..84576e82a 100644
--- a/packages/qgrid-core/src/infrastructure/cache.d.ts
+++ b/packages/qgrid-core/src/infrastructure/cache.d.ts
@@ -1,8 +1,8 @@
 export declare class Cache <K, V> {
   constructor();
 
-  set(key: K, value: V);
-  get(key: K): V ;
+  set(key: K, value: V): void;
+  get(key: K): V;
   has(key: K): boolean;
   find(key: K): V;
   remove(key: K): void;
diff --git a/packages/qgrid-core/src/infrastructure/composite.d.ts b/packages/qgrid-core/src/infrastructure/composite.d.ts
index 0a1dbb395..59cce1dfa 100644
--- a/packages/qgrid-core/src/infrastructure/composite.d.ts
+++ b/packages/qgrid-core/src/infrastructure/composite.d.ts
@@ -1,7 +1,7 @@
 import { Command } from '../command/command';
 
 export declare class Composite {
-  static func<T, A>(list: ((...args) => T)[], reducer?: (A, T) => A, memo?: A): (...args) => A;
+  static func<T, A>(list: ((...args: A) => T)[], reducer?: (a: A, t: T) => A, memo?: A): (...args: A) => T;
   static command(list: Command[]): Command;
   static list(list: any[]): any[];
   static object(list: any[], memo: any): any;
diff --git a/packages/qgrid-core/src/rx/rx.d.ts b/packages/qgrid-core/src/rx/rx.d.ts
index 6767812b6..80e6e3b37 100644
--- a/packages/qgrid-core/src/rx/rx.d.ts
+++ b/packages/qgrid-core/src/rx/rx.d.ts
@@ -2,108 +2,112 @@ import { Event } from '../event/event';
 import { Disposable } from '../infrastructure/disposable';
 
 export declare interface ObserverLike<T> {
-	next(value?: T): void;
-	error(ex: Error): void;
-	complete(): void;
+  next(value?: T): void;
+  error(ex: Error): void;
+  complete(): void;
 }
 
 export declare interface UnsubscribableLike {
-	readonly closed: boolean;
-	unsubscribe(): void;
+  readonly closed: boolean;
+  unsubscribe(): void;
 }
 
 export declare interface SubscribableLike<T> {
-	subscribe(observer?: Partial<ObserverLike<T>>): UnsubscribableLike;
-	/** @deprecated Use an observer instead of an error callback */
-	subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): UnsubscribableLike;
-	/** @deprecated Use an observer instead of a complete callback */
-	subscribe(next: null | undefined | ((value: T) => void), error: null | undefined, complete: () => void): UnsubscribableLike;
-	subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): UnsubscribableLike;
+  subscribe(observer?: Partial<ObserverLike<T>>): UnsubscribableLike;
+  /** @deprecated Use an observer instead of an error callback */
+  subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): UnsubscribableLike;
+  /** @deprecated Use an observer instead of a complete callback */
+  subscribe(next: null | undefined | ((value: T) => void), error: null | undefined, complete: () => void): UnsubscribableLike;
+  subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): UnsubscribableLike;
 }
 
 export type UnaryFunctionLike<T, R> = (source: T) => R;
 
 // eslint-disable-next-line no-use-before-define
 export declare interface OperatorFunctionLike<T, R> extends UnaryFunctionLike<ObservableLike<T>, ObservableLike<R>> {
-	type?: T;
+  type?: T;
 }
 export declare interface ObservableLike<T> extends SubscribableLike<T> {
-	toPromise(): Promise<T>;
+  toPromise(): Promise<T>;
 
-	pipe(): ObservableLike<T>;
-	pipe<A>(op1: OperatorFunctionLike<T, A>): ObservableLike<A>;
-	pipe<A, B>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>): ObservableLike<B>;
-	pipe<A, B, C>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>, op3: OperatorFunctionLike<B, C>): ObservableLike<C>;
-	pipe<A, B, C, D>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>
-	): ObservableLike<D>;
-	pipe<A, B, C, D, E>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>
-	): ObservableLike<E>;
-	pipe<A, B, C, D, E, F>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>
-	): ObservableLike<F>;
-	pipe<A, B, C, D, E, F, G>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>
-	): ObservableLike<G>;
-	pipe<A, B, C, D, E, F, G, H>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>
-	): ObservableLike<H>;
-	pipe<A, B, C, D, E, F, G, H, I>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>,
-		op9: OperatorFunctionLike<H, I>
-	): ObservableLike<I>;
-	pipe<A, B, C, D, E, F, G, H, I>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>,
-		op9: OperatorFunctionLike<H, I>,
-		...operations: OperatorFunctionLike<any, any>[]
-	): ObservableLike<any>;
+  pipe(): ObservableLike<T>;
+  pipe<A>(op1: OperatorFunctionLike<T, A>): ObservableLike<A>;
+  pipe<A, B>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>): ObservableLike<B>;
+  pipe<A, B, C>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>, op3: OperatorFunctionLike<B, C>): ObservableLike<C>;
+  pipe<A, B, C, D>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>
+  ): ObservableLike<D>;
+  pipe<A, B, C, D, E>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>
+  ): ObservableLike<E>;
+  pipe<A, B, C, D, E, F>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>
+  ): ObservableLike<F>;
+  pipe<A, B, C, D, E, F, G>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>
+  ): ObservableLike<G>;
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>
+  ): ObservableLike<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>,
+    op9: OperatorFunctionLike<H, I>
+  ): ObservableLike<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>,
+    op9: OperatorFunctionLike<H, I>,
+    ...operations: OperatorFunctionLike<any, any>[]
+  ): ObservableLike<any>;
 }
 
 export declare class ObservableEvent<T> implements ObservableLike<T> {
   constructor(event: Event<T>, disposable: Disposable);
 
   subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): UnsubscribableLike;
-  subscribe(observer: Partial<ObserverLike<T>>): UnsubscribableLike;
+  subscribe(observer?: Partial<ObserverLike<T>>): UnsubscribableLike;
+  /** @deprecated Use an observer instead of an error callback */
+  subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): UnsubscribableLike;
+  /** @deprecated Use an observer instead of a complete callback */
+  subscribe(next: null | undefined | ((value: T) => void), error: null | undefined, complete: () => void): UnsubscribableLike;
 
   toPromise(): Promise<T>;
 
@@ -112,68 +116,68 @@ export declare class ObservableEvent<T> implements ObservableLike<T> {
   pipe<A, B>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>): ObservableLike<B>;
   pipe<A, B, C>(op1: OperatorFunctionLike<T, A>, op2: OperatorFunctionLike<A, B>, op3: OperatorFunctionLike<B, C>): ObservableLike<C>;
   pipe<A, B, C, D>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>
-	): ObservableLike<D>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>
+  ): ObservableLike<D>;
   pipe<A, B, C, D, E>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>
-	): ObservableLike<E>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>
+  ): ObservableLike<E>;
   pipe<A, B, C, D, E, F>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>
-	): ObservableLike<F>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>
+  ): ObservableLike<F>;
   pipe<A, B, C, D, E, F, G>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>
-	): ObservableLike<G>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>
+  ): ObservableLike<G>;
   pipe<A, B, C, D, E, F, G, H>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>
-	): ObservableLike<H>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>
+  ): ObservableLike<H>;
   pipe<A, B, C, D, E, F, G, H, I>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>,
-		op9: OperatorFunctionLike<H, I>
-	): ObservableLike<I>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>,
+    op9: OperatorFunctionLike<H, I>
+  ): ObservableLike<I>;
   pipe<A, B, C, D, E, F, G, H, I>(
-		op1: OperatorFunctionLike<T, A>,
-		op2: OperatorFunctionLike<A, B>,
-		op3: OperatorFunctionLike<B, C>,
-		op4: OperatorFunctionLike<C, D>,
-		op5: OperatorFunctionLike<D, E>,
-		op6: OperatorFunctionLike<E, F>,
-		op7: OperatorFunctionLike<F, G>,
-		op8: OperatorFunctionLike<G, H>,
-		op9: OperatorFunctionLike<H, I>,
-		...operations: OperatorFunctionLike<any, any>[]
-	): ObservableLike<any>;
+    op1: OperatorFunctionLike<T, A>,
+    op2: OperatorFunctionLike<A, B>,
+    op3: OperatorFunctionLike<B, C>,
+    op4: OperatorFunctionLike<C, D>,
+    op5: OperatorFunctionLike<D, E>,
+    op6: OperatorFunctionLike<E, F>,
+    op7: OperatorFunctionLike<F, G>,
+    op8: OperatorFunctionLike<G, H>,
+    op9: OperatorFunctionLike<H, I>,
+    ...operations: OperatorFunctionLike<any, any>[]
+  ): ObservableLike<any>;
 }
 
 export declare class ObservableReplyEvent<T> extends ObservableEvent<T> {
diff --git a/packages/qgrid-core/src/selection/selection.service.d.ts b/packages/qgrid-core/src/selection/selection.service.d.ts
index 791b2e9da..68206297d 100644
--- a/packages/qgrid-core/src/selection/selection.service.d.ts
+++ b/packages/qgrid-core/src/selection/selection.service.d.ts
@@ -1,3 +1,6 @@
+import { Row } from '../dom/row';
+import { Column } from '../dom/column';
+import { Cell } from '../dom/cell';
 import { Model } from '../model/model';
 
 export declare class SelectionService {
@@ -5,6 +8,6 @@ export declare class SelectionService {
 
   lookup(items: any[], unit?: string): any[];
   map(entries: any[]): any[];
-  keyFactory<K>(unit: string): (any) => K;
+  keyFactory<K>(unit: string): (item: 'column' | 'row' | 'cell' | 'mix') => K;
   hashFactory(): (key: string) => any;
 }
diff --git a/packages/qgrid-core/src/services/fastdom.d.ts b/packages/qgrid-core/src/services/fastdom.d.ts
index fc4f75a43..4b95d743e 100644
--- a/packages/qgrid-core/src/services/fastdom.d.ts
+++ b/packages/qgrid-core/src/services/fastdom.d.ts
@@ -1,6 +1,6 @@
 export declare class Fastdom {
   static mutate: (task: () => void) => any;
   static measure: (task: () => void) => any;
-  static clear(token: any);
+  static clear(token: any): boolean;
   static invoke: (task: () => void) => any;
 }
diff --git a/packages/qgrid-core/src/sort/sort.service.d.ts b/packages/qgrid-core/src/sort/sort.service.d.ts
index 671650622..3374dfbc2 100644
--- a/packages/qgrid-core/src/sort/sort.service.d.ts
+++ b/packages/qgrid-core/src/sort/sort.service.d.ts
@@ -1,7 +1,7 @@
 import { Model } from '../model/model';
 
-export declare const getKey: (pair: any) => string;
-export declare const getIndex: (pairs: any[], pairKey: string) => number;
-export declare const getDirection: (pair: any) => string;
-export declare const getMap: (pairs: any[]) => any;
-export declare function orderFactory(model: Model);
+export declare const getKey: (pair: string | Record<string, any>) => string;
+export declare const getIndex: (pairs: string[] | Record<string, any>[], pairKey: string) => number;
+export declare const getDirection: (pair: string | Record<string, any>) => string;
+export declare const getMap: (pairs: string[] | Record<string, any>[]) => any;
+export declare function orderFactory(model: Model): (by: any[]) => any[];
diff --git a/packages/qgrid-core/src/types/css.escape.d.ts b/packages/qgrid-core/src/types/css.escape.d.ts
index 62acb5a21..f36cfc149 100644
--- a/packages/qgrid-core/src/types/css.escape.d.ts
+++ b/packages/qgrid-core/src/types/css.escape.d.ts
@@ -1,3 +1,3 @@
 declare module 'css.escape' {
-    export function cssEscape(x: string);
+    export function cssEscape(x: string): any;
 }
diff --git a/packages/qgrid-core/src/view/view.host.d.ts b/packages/qgrid-core/src/view/view.host.d.ts
index c9dcbc6a1..2a4a5a90f 100644
--- a/packages/qgrid-core/src/view/view.host.d.ts
+++ b/packages/qgrid-core/src/view/view.host.d.ts
@@ -5,11 +5,11 @@ export declare class ViewHost {
 
   invalidate(): void;
 
-  mouseDown(e: MouseEvent);
-  mouseUp(e: MouseEvent);
+  mouseDown(e: MouseEvent): void;
+  mouseUp(e: MouseEvent): void;
 
-  mouseMove(e: MouseEvent);
+  mouseMove(e: MouseEvent): void;
 
-  mouseEnter(e: MouseEvent);
-  mouseLeave(e: MouseEvent);
+  mouseEnter(e: MouseEvent): void;
+  mouseLeave(e: MouseEvent): void;
 }