molstar 2.3.2 → 2.3.7

package/lib/commonjs/mol-theme/color/chain-id.d.ts

@@ -8,35 +8,35 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ChainIdColorThemeParams: {
     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<AsymIdType>;
 };
 export declare type ChainIdColorThemeParams = typeof ChainIdColorThemeParams;
 export declare function getChainIdColorThemeParams(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<AsymIdType>;
 };
 declare type AsymIdType = 'auth' | 'label';

package/lib/commonjs/mol-theme/color/element-index.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ElementIndexColorThemeParams: {
     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 ElementIndexColorThemeParams = typeof ElementIndexColorThemeParams;
 export declare function getElementIndexColorThemeParams(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 ElementIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<ElementIndexColorThemeParams>): ColorTheme<ElementIndexColorThemeParams>;
 export declare const ElementIndexColorThemeProvider: ColorTheme.Provider<ElementIndexColorThemeParams, 'element-index'>;

package/lib/commonjs/mol-theme/color/element-symbol.d.ts

@@ -133,27 +133,27 @@ export declare type ElementSymbolColors = typeof ElementSymbolColors;
 export declare const ElementSymbolColorThemeParams: {
     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;
@@ -162,27 +162,27 @@ export declare type ElementSymbolColorThemeParams = typeof ElementSymbolColorThe
 export declare function getElementSymbolColorThemeParams(ctx: ThemeDataContext): {
     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;

package/lib/commonjs/mol-theme/color/entity-id.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const EntityIdColorThemeParams: {
     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 EntityIdColorThemeParams = typeof EntityIdColorThemeParams;
 export declare function getEntityIdColorThemeParams(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 EntityIdColorTheme(ctx: ThemeDataContext, props: PD.Values<EntityIdColorThemeParams>): ColorTheme<EntityIdColorThemeParams>;
 export declare const EntityIdColorThemeProvider: ColorTheme.Provider<EntityIdColorThemeParams, 'entity-id'>;

package/lib/commonjs/mol-theme/color/entity-source.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const EntitySourceColorThemeParams: {
     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 EntitySourceColorThemeParams = typeof EntitySourceColorThemeParams;
 export declare function getEntitySourceColorThemeParams(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 EntitySourceColorTheme(ctx: ThemeDataContext, props: PD.Values<EntitySourceColorThemeParams>): ColorTheme<EntitySourceColorThemeParams>;
 export declare const EntitySourceColorThemeProvider: ColorTheme.Provider<EntitySourceColorThemeParams, 'entity-source'>;

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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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'>;