npm - molstar - Versions diffs - 2.3.9 → 2.4.0 - Mend

molstar 2.3.9 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (550) hide show

package/lib/commonjs/mol-theme/color/illustrative.d.ts CHANGED Viewed

@@ -8,35 +8,35 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const IllustrativeColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
     asymId: PD.Select<"label" | "auth">;
 };
 export declare type IllustrativeColorThemeParams = typeof IllustrativeColorThemeParams;
 export declare function getIllustrativeColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
     asymId: PD.Select<"label" | "auth">;
 };
 export declare function IllustrativeColorTheme(ctx: ThemeDataContext, props: PD.Values<IllustrativeColorThemeParams>): ColorTheme<IllustrativeColorThemeParams>;

package/lib/commonjs/mol-theme/color/model-index.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ModelIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type ModelIndexColorThemeParams = typeof ModelIndexColorThemeParams;
 export declare function getModelIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function ModelIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<ModelIndexColorThemeParams>): ColorTheme<ModelIndexColorThemeParams>;
 export declare const ModelIndexColorThemeProvider: ColorTheme.Provider<ModelIndexColorThemeParams, 'model-index'>;

package/lib/commonjs/mol-theme/color/operator-hkl.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const OperatorHklColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type OperatorHklColorThemeParams = typeof OperatorHklColorThemeParams;
 export declare function getOperatorHklColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function OperatorHklColorTheme(ctx: ThemeDataContext, props: PD.Values<OperatorHklColorThemeParams>): ColorTheme<OperatorHklColorThemeParams>;
 export declare const OperatorHklColorThemeProvider: ColorTheme.Provider<OperatorHklColorThemeParams, 'operator-hkl'>;

package/lib/commonjs/mol-theme/color/operator-name.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const OperatorNameColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type OperatorNameColorThemeParams = typeof OperatorNameColorThemeParams;
 export declare function getOperatorNameColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function OperatorNameColorTheme(ctx: ThemeDataContext, props: PD.Values<OperatorNameColorThemeParams>): ColorTheme<OperatorNameColorThemeParams>;
 export declare const OperatorNameColorThemeProvider: ColorTheme.Provider<OperatorNameColorThemeParams, 'operator-name'>;

package/lib/commonjs/mol-theme/color/polymer-id.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const PolymerIdColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type PolymerIdColorThemeParams = typeof PolymerIdColorThemeParams;
 export declare function getPolymerIdColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function PolymerIdColorTheme(ctx: ThemeDataContext, props: PD.Values<PolymerIdColorThemeParams>): ColorTheme<PolymerIdColorThemeParams>;
 export declare const PolymerIdColorThemeProvider: ColorTheme.Provider<PolymerIdColorThemeParams, 'polymer-id'>;

package/lib/commonjs/mol-theme/color/polymer-index.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const PolymerIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type PolymerIndexColorThemeParams = typeof PolymerIndexColorThemeParams;
 export declare function getPolymerIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type PolymerIndexColorThemeProps = PD.Values<typeof PolymerIndexColorThemeParams>;
 export declare function PolymerIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<PolymerIndexColorThemeParams>): ColorTheme<PolymerIndexColorThemeParams>;

package/lib/commonjs/mol-theme/color/unit-index.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const UnitIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type UnitIndexColorThemeParams = typeof UnitIndexColorThemeParams;
 export declare function getUnitIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function UnitIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<UnitIndexColorThemeParams>): ColorTheme<UnitIndexColorThemeParams>;
 export declare const UnitIndexColorThemeProvider: ColorTheme.Provider<UnitIndexColorThemeParams, 'unit-index'>;

package/lib/commonjs/mol-theme/color.d.ts CHANGED Viewed

@@ -56,108 +56,108 @@ declare namespace ColorTheme {
     export const BuiltIn: {
         'atom-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "atom-id">;
         'carbohydrate-symbol': Provider<{}, "carbohydrate-symbol">;
         'chain-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
             asymId: PD.Select<"label" | "auth">;
         }, "chain-id">;
         'element-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "element-index">;
         'element-symbol': Provider<{
             carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
                 palette: PD.NamedParams<PD.Normalize<{
-                    list: any;
-                }>, "colors"> | PD.NamedParams<PD.Normalize<{
                     maxCount: any;
                     hue: any;
                     chroma: any;
                     luminance: any;
                     clusteringStepCount: any;
                     minSampleCount: any;
-                }>, "generate">;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
                 asymId: "label" | "auth";
             }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
                 palette: PD.NamedParams<PD.Normalize<{
-                    list: any;
-                }>, "colors"> | PD.NamedParams<PD.Normalize<{
                     maxCount: any;
                     hue: any;
                     chroma: any;
                     luminance: any;
                     clusteringStepCount: any;
                     minSampleCount: any;
-                }>, "generate">;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
             }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
             saturation: PD.Numeric;
             lightness: PD.Numeric;
         }, "element-symbol">;
         'entity-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
-        }, "entity-id">;
-        'entity-source': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "entity-id">;
+        'entity-source': Provider<{
+            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "entity-source">;
         hydrophobicity: Provider<{
             list: PD.ColorList;
@@ -165,34 +165,34 @@ declare namespace ColorTheme {
         }, "hydrophobicity">;
         illustrative: Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
             asymId: PD.Select<"label" | "auth">;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "model-index">;
         'molecule-type': Provider<{
             saturation: PD.Numeric;
@@ -204,33 +204,33 @@ declare namespace ColorTheme {
         }, "occupancy">;
         'operator-hkl': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
-        }, "operator-hkl">;
-        'operator-name': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "operator-hkl">;
+        'operator-name': Provider<{
+            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "operator-name">;
         'partial-charge': Provider<{
             domain: PD.Interval;
@@ -238,33 +238,33 @@ declare namespace ColorTheme {
         }, "partial-charge">;
         'polymer-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
-        }, "polymer-id">;
-        'polymer-index': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "polymer-id">;
+        'polymer-index': Provider<{
+            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "polymer-index">;
         'residue-name': Provider<{
             saturation: PD.Numeric;
@@ -284,18 +284,18 @@ declare namespace ColorTheme {
         }, "uncertainty">;
         'unit-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "interpolate" | "set";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate">>;
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "set" | "interpolate";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors">>;
         }, "unit-index">;
         uniform: Provider<{
             value: PD.Color;