diff --git a/src/mol-state/action.ts b/src/mol-state/action.ts
index a4e6fb42ba7902578998fed632c2ff5ec181c5b2..024fe3e0d3c14db89d0c145be1c67787ad200b74 100644
--- a/src/mol-state/action.ts
+++ b/src/mol-state/action.ts
@@ -13,7 +13,7 @@ import { Transformer } from './transformer';
 
 export { StateAction };
 
-interface StateAction<A extends StateObject = StateObject, T = any, P = unknown> {
+interface StateAction<A extends StateObject = StateObject, T = any, P extends {} = {}> {
     create(params: P): StateAction.Instance,
     readonly id: UUID,
     readonly definition: StateAction.Definition<A, T, P>
@@ -30,14 +30,14 @@ namespace StateAction {
         params: any
     }
 
-    export interface ApplyParams<A extends StateObject = StateObject, P = unknown> {
+    export interface ApplyParams<A extends StateObject = StateObject, P extends {} = {}> {
         cell: StateObjectCell,
         a: A,
         state: State,
         params: P
     }
 
-    export interface Definition<A extends StateObject = StateObject, T = any, P = unknown> {
+    export interface Definition<A extends StateObject = StateObject, T = any, P extends {} = {}> {
         readonly from: StateObject.Ctor[],
         readonly display?: { readonly name: string, readonly description?: string },
 
@@ -52,7 +52,7 @@ namespace StateAction {
         isApplicable?(a: A, globalCtx: unknown): boolean
     }
 
-    export function create<A extends StateObject, T, P>(definition: Definition<A, T, P>): StateAction<A, T, P> {
+    export function create<A extends StateObject, T, P extends {} = {}>(definition: Definition<A, T, P>): StateAction<A, T, P> {
         const action: StateAction<A, T, P> = {
             create(params) { return { action, params }; },
             id: UUID.create22(),
diff --git a/src/mol-state/transform.ts b/src/mol-state/transform.ts
index bda45d3315c9b945aa8b34b36bd9bb85d4dfe2d7..dc290b1d3655d3d32ea73a9a74616af47f765356 100644
--- a/src/mol-state/transform.ts
+++ b/src/mol-state/transform.ts
@@ -8,7 +8,7 @@ import { StateObject } from './object';
 import { Transformer } from './transformer';
 import { UUID } from 'mol-util';
 
-export interface Transform<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
+export interface Transform<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
     readonly parent: Transform.Ref,
     readonly transformer: Transformer<A, B, P>,
     readonly props: Transform.Props,
@@ -33,7 +33,7 @@ export namespace Transform {
         props?: Props
     }
 
-    export function create<A extends StateObject, B extends StateObject, P>(parent: Ref, transformer: Transformer<A, B, P>, params?: P, options?: Options): Transform<A, B, P> {
+    export function create<A extends StateObject, B extends StateObject, P extends {} = {}>(parent: Ref, transformer: Transformer<A, B, P>, params?: P, options?: Options): Transform<A, B, P> {
         const ref = options && options.ref ? options.ref : UUID.create22() as string as Ref;
         return {
             parent,
diff --git a/src/mol-state/transformer.ts b/src/mol-state/transformer.ts
index e9b8acfa27dc1071441ced6c820889c5bf253315..673e2786960828599411424d1099503e9fd2052b 100644
--- a/src/mol-state/transformer.ts
+++ b/src/mol-state/transformer.ts
@@ -10,7 +10,7 @@ import { Transform } from './transform';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { StateAction } from './action';
 
-export interface Transformer<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
+export interface Transformer<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
     apply(parent: Transform.Ref, params?: P, props?: Partial<Transform.Options>): Transform<A, B, P>,
     toAction(): StateAction<A, void, P>,
     readonly namespace: string,
@@ -29,14 +29,14 @@ export namespace Transformer {
         return !!obj && typeof (obj as Transformer).toAction === 'function' && typeof (obj as Transformer).apply === 'function';
     }
 
-    export interface ApplyParams<A extends StateObject = StateObject, P = unknown> {
+    export interface ApplyParams<A extends StateObject = StateObject, P extends {} = {}> {
         a: A,
         params: P,
         /** A cache object that is purged each time the corresponding StateObject is removed or recreated. */
         cache: unknown
     }
 
-    export interface UpdateParams<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
+    export interface UpdateParams<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
         a: A,
         b: B,
         oldParams: P,
@@ -56,7 +56,7 @@ export namespace Transformer {
         areEqual?(oldParams: P, newParams: P): boolean
     }
 
-    export interface Definition<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
+    export interface Definition<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
         readonly name: string,
         readonly from: StateObject.Ctor[],
         readonly to: StateObject.Ctor[],
@@ -112,7 +112,7 @@ export namespace Transformer {
         return fromTypeIndex.get(type) || [];
     }
 
-    export function create<A extends StateObject, B extends StateObject, P>(namespace: string, definition: Definition<A, B, P>) {
+    export function create<A extends StateObject, B extends StateObject, P extends {} = {}>(namespace: string, definition: Definition<A, B, P>) {
         const { name } = definition;
         const id = `${namespace}.${name}` as Id;
 
@@ -134,10 +134,10 @@ export namespace Transformer {
     }
 
     export function factory(namespace: string) {
-        return <A extends StateObject, B extends StateObject, P>(definition: Definition<A, B, P>) => create(namespace, definition);
+        return <A extends StateObject, B extends StateObject, P extends {} = {}>(definition: Definition<A, B, P>) => create(namespace, definition);
     }
 
-    export const ROOT = create<any, any, any>('build-in', {
+    export const ROOT = create<any, any, {}>('build-in', {
         name: 'root',
         from: [],
         to: [],
diff --git a/src/mol-state/tree/transient.ts b/src/mol-state/tree/transient.ts
index 39c40fdf86a4f24d8cbb09a03feeda2ca773e029..279ed6fcf771db3ec9a201718a82863a3712b5a3 100644
--- a/src/mol-state/tree/transient.ts
+++ b/src/mol-state/tree/transient.ts
@@ -134,7 +134,7 @@ class TransientTree implements StateTree {
     }
 
     /** Calls Transform.definition.params.areEqual if available, otherwise uses shallowEqual to check if the params changed */
-    setParams(ref: Transform.Ref, params: unknown) {
+    setParams(ref: Transform.Ref, params: any) {
         ensurePresent(this.transforms, ref);
 
         const transform = this.transforms.get(ref)!;