1 | // Last module patch version validated against: 3.0.0
|
2 |
|
3 | // -----------------------------------------------------------------------
|
4 | // Categorical
|
5 | // -----------------------------------------------------------------------
|
6 | /**
|
7 | * An array of ten categorical colors represented as RGB hexadecimal strings.
|
8 | */
|
9 | export const schemeCategory10: ReadonlyArray<string>;
|
10 | /**
|
11 | * An array of eight categorical colors represented as RGB hexadecimal strings.
|
12 | */
|
13 | export const schemeAccent: ReadonlyArray<string>;
|
14 | /**
|
15 | * An array of eight categorical colors represented as RGB hexadecimal strings.
|
16 | */
|
17 | export const schemeDark2: ReadonlyArray<string>;
|
18 | /**
|
19 | * An array of twelve categorical colors represented as RGB hexadecimal strings.
|
20 | */
|
21 | export const schemePaired: ReadonlyArray<string>;
|
22 | /**
|
23 | * An array of nine categorical colors represented as RGB hexadecimal strings.
|
24 | */
|
25 | export const schemePastel1: ReadonlyArray<string>;
|
26 | /**
|
27 | * An array of eight categorical colors represented as RGB hexadecimal strings.
|
28 | */
|
29 | export const schemePastel2: ReadonlyArray<string>;
|
30 | /**
|
31 | * An array of nine categorical colors represented as RGB hexadecimal strings.
|
32 | */
|
33 | export const schemeSet1: ReadonlyArray<string>;
|
34 | /**
|
35 | * An array of eight categorical colors represented as RGB hexadecimal strings.
|
36 | */
|
37 | export const schemeSet2: ReadonlyArray<string>;
|
38 | /**
|
39 | * An array of twelve categorical colors represented as RGB hexadecimal strings.
|
40 | */
|
41 | export const schemeSet3: ReadonlyArray<string>;
|
42 | /**
|
43 | * An array of ten categorical colors authored by Tableau as part of Tableau 10 represented as RGB hexadecimal strings.
|
44 | */
|
45 | export const schemeTableau10: ReadonlyArray<string>;
|
46 |
|
47 | // -----------------------------------------------------------------------
|
48 | // Diverging
|
49 | // -----------------------------------------------------------------------
|
50 | /**
|
51 | * Given a number t in the range [0,1], returns the corresponding color from the “BrBG” diverging color scheme represented as an RGB string.
|
52 | *
|
53 | * @param t Number in the range [0, 1].
|
54 | */
|
55 | export function interpolateBrBG(t: number): string;
|
56 |
|
57 | /**
|
58 | * An array of arrays of hexadecimal color strings from the “BrBG” diverging color scheme. The kth element of this array contains
|
59 | * the color scheme of size k; for example, d3.schemeBrBG[9] contains an array of nine strings representing the nine colors of the
|
60 | * brown-blue-green diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
61 | */
|
62 | export const schemeBrBG: ReadonlyArray<ReadonlyArray<string>>;
|
63 |
|
64 | /**
|
65 | * Given a number t in the range [0,1], returns the corresponding color from the “PRGn” diverging color scheme represented as an RGB string.
|
66 | *
|
67 | * @param t Number in the range [0, 1].
|
68 | */
|
69 | export function interpolatePRGn(t: number): string;
|
70 |
|
71 | /**
|
72 | * An array of arrays of hexadecimal color strings from the “PRGn” diverging color scheme. The kth element of this array contains
|
73 | * the color scheme of size k; for example, d3.schemePRGn[9] contains an array of nine strings representing the nine colors of the
|
74 | * purple-green diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
75 | */
|
76 | export const schemePRGn: ReadonlyArray<ReadonlyArray<string>>;
|
77 |
|
78 | /**
|
79 | * Given a number t in the range [0,1], returns the corresponding color from the “PiYG” diverging color scheme represented as an RGB string.
|
80 | *
|
81 | * @param t Number in the range [0, 1].
|
82 | */
|
83 | export function interpolatePiYG(t: number): string;
|
84 |
|
85 | /**
|
86 | * An array of arrays of hexadecimal color strings from the “PiYG” diverging color scheme. The kth element of this array contains
|
87 | * the color scheme of size k; for example, d3.schemePiYG[9] contains an array of nine strings representing the nine colors of the
|
88 | * pink-yellow-green diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
89 | */
|
90 | export const schemePiYG: ReadonlyArray<ReadonlyArray<string>>;
|
91 |
|
92 | /**
|
93 | * Given a number t in the range [0,1], returns the corresponding color from the “PuOr” diverging color scheme represented as an RGB string.
|
94 | *
|
95 | * @param t Number in the range [0, 1].
|
96 | */
|
97 | export function interpolatePuOr(t: number): string;
|
98 |
|
99 | /**
|
100 | * An array of arrays of hexadecimal color strings from the “PuOr” diverging color scheme. The kth element of this array contains
|
101 | * the color scheme of size k; for example, d3.schemePuOr[9] contains an array of nine strings representing the nine colors of the
|
102 | * purple-orange diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
103 | */
|
104 | export const schemePuOr: ReadonlyArray<ReadonlyArray<string>>;
|
105 |
|
106 | /**
|
107 | * Given a number t in the range [0,1], returns the corresponding color from the “RdBu” diverging color scheme represented as an RGB string.
|
108 | *
|
109 | * @param t Number in the range [0, 1].
|
110 | */
|
111 | export function interpolateRdBu(t: number): string;
|
112 |
|
113 | /**
|
114 | * An array of arrays of hexadecimal color strings from the “RdBu” diverging color scheme. The kth element of this array contains
|
115 | * the color scheme of size k; for example, d3.schemeRdBu[9] contains an array of nine strings representing the nine colors of the
|
116 | * red-blue diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
117 | */
|
118 | export const schemeRdBu: ReadonlyArray<ReadonlyArray<string>>;
|
119 |
|
120 | /**
|
121 | * Given a number t in the range [0,1], returns the corresponding color from the “RdGy” diverging color scheme represented as an RGB string.
|
122 | *
|
123 | * @param t Number in the range [0, 1].
|
124 | */
|
125 | export function interpolateRdGy(t: number): string;
|
126 |
|
127 | /**
|
128 | * An array of arrays of hexadecimal color strings from the “RdGy” diverging color scheme. The kth element of this array contains
|
129 | * the color scheme of size k; for example, d3.schemeRdGy[9] contains an array of nine strings representing the nine colors of the
|
130 | * red-grey diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
131 | */
|
132 | export const schemeRdGy: ReadonlyArray<ReadonlyArray<string>>;
|
133 |
|
134 | /**
|
135 | * Given a number t in the range [0,1], returns the corresponding color from the “RdYlBu” diverging color scheme represented as an RGB string.
|
136 | *
|
137 | * @param t Number in the range [0, 1].
|
138 | */
|
139 | export function interpolateRdYlBu(t: number): string;
|
140 |
|
141 | /**
|
142 | * An array of arrays of hexadecimal color strings from the “RdYlBu” diverging color scheme. The kth element of this array contains
|
143 | * the color scheme of size k; for example, d3.schemeRdYlBu[9] contains an array of nine strings representing the nine colors of the
|
144 | * red-yellow-blue diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
145 | */
|
146 | export const schemeRdYlBu: ReadonlyArray<ReadonlyArray<string>>;
|
147 |
|
148 | /**
|
149 | * Given a number t in the range [0,1], returns the corresponding color from the “RdYlGn” diverging color scheme represented as an RGB string.
|
150 | *
|
151 | * @param t Number in the range [0, 1].
|
152 | */
|
153 | export function interpolateRdYlGn(t: number): string;
|
154 |
|
155 | /**
|
156 | * An array of arrays of hexadecimal color strings from the “RdYlGn” diverging color scheme. The kth element of this array contains
|
157 | * the color scheme of size k; for example, d3.schemeRdYlGn[9] contains an array of nine strings representing the nine colors of the
|
158 | * red-yellow-green diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
159 | */
|
160 | export const schemeRdYlGn: ReadonlyArray<ReadonlyArray<string>>;
|
161 |
|
162 | /**
|
163 | * Given a number t in the range [0,1], returns the corresponding color from the “Spectral” diverging color scheme represented as an RGB string.
|
164 | *
|
165 | * @param t Number in the range [0, 1].
|
166 | */
|
167 | export function interpolateSpectral(t: number): string;
|
168 |
|
169 | /**
|
170 | * An array of arrays of hexadecimal color strings from the “Spectral” diverging color scheme. The kth element of this array contains
|
171 | * the color scheme of size k; for example, d3.schemeSpectral[9] contains an array of nine strings representing the nine colors of the
|
172 | * spectral diverging color scheme. Diverging color schemes support a size k ranging from 3 to 11.
|
173 | */
|
174 | export const schemeSpectral: ReadonlyArray<ReadonlyArray<string>>;
|
175 |
|
176 | // -----------------------------------------------------------------------
|
177 | // Sequential
|
178 | // -----------------------------------------------------------------------
|
179 | /**
|
180 | * Given a number t in the range [0,1], returns the corresponding color from the “Blues” sequential color scheme represented as an RGB string.
|
181 | *
|
182 | * @param t Number in the range [0, 1].
|
183 | */
|
184 | export function interpolateBlues(t: number): string;
|
185 |
|
186 | /**
|
187 | * An array of arrays of hexadecimal color strings from the “Blues” sequential color scheme. The kth element of this array contains
|
188 | * the color scheme of size k; for example, d3.schemeBlues[9] contains an array of nine strings representing the nine colors of the
|
189 | * blue sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
190 | */
|
191 | export const schemeBlues: ReadonlyArray<ReadonlyArray<string>>;
|
192 |
|
193 | /**
|
194 | * Given a number t in the range [0,1], returns the corresponding color from the “Greens” sequential color scheme represented as an RGB string.
|
195 | *
|
196 | * @param t Number in the range [0, 1].
|
197 | */
|
198 | export function interpolateGreens(t: number): string;
|
199 |
|
200 | /**
|
201 | * An array of arrays of hexadecimal color strings from the “Greens” sequential color scheme. The kth element of this array contains
|
202 | * the color scheme of size k; for example, d3.schemeGreens[9] contains an array of nine strings representing the nine colors of the
|
203 | * green sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
204 | */
|
205 | export const schemeGreens: ReadonlyArray<ReadonlyArray<string>>;
|
206 |
|
207 | /**
|
208 | * Given a number t in the range [0,1], returns the corresponding color from the “Greys” sequential color scheme represented as an RGB string.
|
209 | *
|
210 | * @param t Number in the range [0, 1].
|
211 | */
|
212 | export function interpolateGreys(t: number): string;
|
213 |
|
214 | /**
|
215 | * An array of arrays of hexadecimal color strings from the “Greys” sequential color scheme. The kth element of this array contains
|
216 | * the color scheme of size k; for example, d3.schemeGreys[9] contains an array of nine strings representing the nine colors of the
|
217 | * grey sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
218 | */
|
219 | export const schemeGreys: ReadonlyArray<ReadonlyArray<string>>;
|
220 |
|
221 | /**
|
222 | * Given a number t in the range [0,1], returns the corresponding color from the “Oranges” sequential color scheme represented as an RGB string.
|
223 | *
|
224 | * @param t Number in the range [0, 1].
|
225 | */
|
226 | export function interpolateOranges(t: number): string;
|
227 |
|
228 | /**
|
229 | * An array of arrays of hexadecimal color strings from the “Oranges” sequential color scheme. The kth element of this array contains
|
230 | * the color scheme of size k; for example, d3.schemeOranges[9] contains an array of nine strings representing the nine colors of the
|
231 | * orange sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
232 | */
|
233 | export const schemeOranges: ReadonlyArray<ReadonlyArray<string>>;
|
234 |
|
235 | /**
|
236 | * Given a number t in the range [0,1], returns the corresponding color from the “Purples” sequential color scheme represented as an RGB string.
|
237 | *
|
238 | * @param t Number in the range [0, 1].
|
239 | */
|
240 | export function interpolatePurples(t: number): string;
|
241 |
|
242 | /**
|
243 | * An array of arrays of hexadecimal color strings from the “Purples” sequential color scheme. The kth element of this array contains
|
244 | * the color scheme of size k; for example, d3.schemePurples[9] contains an array of nine strings representing the nine colors of the
|
245 | * purple sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
246 | */
|
247 | export const schemePurples: ReadonlyArray<ReadonlyArray<string>>;
|
248 |
|
249 | /**
|
250 | * Given a number t in the range [0,1], returns the corresponding color from the “Reds” sequential color scheme represented as an RGB string.
|
251 | *
|
252 | * @param t Number in the range [0, 1].
|
253 | */
|
254 | export function interpolateReds(t: number): string;
|
255 |
|
256 | /**
|
257 | * An array of arrays of hexadecimal color strings from the “Reds” sequential color scheme. The kth element of this array contains
|
258 | * the color scheme of size k; for example, d3.schemeReds[9] contains an array of nine strings representing the nine colors of the
|
259 | * red sequential color scheme. Sequential, single-hue color schemes support a size k ranging from 3 to 9.
|
260 | */
|
261 | export const schemeReds: ReadonlyArray<ReadonlyArray<string>>;
|
262 |
|
263 | // -----------------------------------------------------------------------
|
264 | // Sequential(Multi-Hue)
|
265 | // -----------------------------------------------------------------------
|
266 |
|
267 | /**
|
268 | * Given a number t in the range [0,1], returns the corresponding color from the “turbo” color scheme by Anton Mikhailov.
|
269 | *
|
270 | * @param t A number in the interval [0, 1].
|
271 | */
|
272 | export function interpolateTurbo(t: number): string;
|
273 |
|
274 | /**
|
275 | * Given a number t in the range [0,1], returns the corresponding color from the “viridis” perceptually-uniform color scheme designed by van der Walt, Smith and Firing for matplotlib,
|
276 | * represented as an RGB string.
|
277 | *
|
278 | * @param t A number in the interval [0, 1].
|
279 | */
|
280 | export function interpolateViridis(t: number): string;
|
281 |
|
282 | /**
|
283 | * Given a number t in the range [0,1], returns the corresponding color from the “inferno” perceptually-uniform color scheme designed by van der Walt and Smith for matplotlib,
|
284 | * represented as an RGB string.
|
285 | *
|
286 | * @param t A number in the interval [0, 1].
|
287 | */
|
288 | export function interpolateInferno(t: number): string;
|
289 |
|
290 | /**
|
291 | * Given a number t in the range [0,1], returns the corresponding color from the “magma” perceptually-uniform color scheme designed by van der Walt and Smith for matplotlib,
|
292 | * represented as an RGB string.
|
293 | *
|
294 | * @param t A number in the interval [0, 1].
|
295 | */
|
296 | export function interpolateMagma(t: number): string;
|
297 |
|
298 | /**
|
299 | * Given a number t in the range [0,1], returns the corresponding color from the “plasma” perceptually-uniform color scheme designed by van der Walt and Smith for matplotlib,
|
300 | * represented as an RGB string.
|
301 | *
|
302 | * @param t A number in the interval [0, 1].
|
303 | */
|
304 | export function interpolatePlasma(t: number): string;
|
305 |
|
306 | /**
|
307 | * Given a number t in the range [0,1], returns the corresponding color from the “plasma” perceptually-uniform color scheme designed by van der Walt and Smith for matplotlib,
|
308 | * represented as an RGB string.
|
309 | *
|
310 | * @param t A number in the interval [0, 1].
|
311 | */
|
312 | export function interpolateCividis(t: number): string;
|
313 |
|
314 | /**
|
315 | * Given a number t in the range [0,1], returns the corresponding color from a 180° rotation of Niccoli’s perceptual rainbow, represented as an RGB string.
|
316 | *
|
317 | * @param t A number in the interval [0, 1].
|
318 | */
|
319 | export function interpolateWarm(t: number): string;
|
320 |
|
321 | /**
|
322 | * Given a number t in the range [0,1], returns the corresponding color from Niccoli’s perceptual rainbow, represented as an RGB string.
|
323 | *
|
324 | * @param t A number in the interval [0, 1].
|
325 | */
|
326 | export function interpolateCool(t: number): string;
|
327 |
|
328 | /**
|
329 | * Given a number t in the range [0,1], returns the corresponding color from d3.interpolateWarm scale from [0.0, 0.5] followed by the d3.interpolateCool scale from [0.5, 1.0],
|
330 | * thus implementing the cyclical less-angry rainbow color scheme.
|
331 | *
|
332 | * @param t A number in the interval [0, 1].
|
333 | */
|
334 | export function interpolateRainbow(t: number): string;
|
335 |
|
336 | /**
|
337 | * Given a number t in the range [0,1], returns the corresponding color from the “sinebow” color scheme by Jim Bumgardner and Charlie Loyd.
|
338 | *
|
339 | * @param t A number in the interval [0, 1].
|
340 | */
|
341 | export function interpolateSinebow(t: number): string;
|
342 |
|
343 | /**
|
344 | * Given a number t in the range [0,1], returns the corresponding color from Green’s default Cubehelix represented as an RGB string.
|
345 | *
|
346 | * @param t A number in the interval [0, 1].
|
347 | */
|
348 | export function interpolateCubehelixDefault(t: number): string;
|
349 |
|
350 | /**
|
351 | * Given a number t in the range [0,1], returns the corresponding color from the “BuGn” sequential color scheme represented as an RGB string.
|
352 | *
|
353 | * @param t Number in the range [0, 1].
|
354 | */
|
355 | export function interpolateBuGn(t: number): string;
|
356 |
|
357 | /**
|
358 | * An array of arrays of hexadecimal color strings from the “BuGn” sequential color scheme. The kth element of this array contains
|
359 | * the color scheme of size k; for example, d3.schemeBuGn[9] contains an array of nine strings representing the nine colors of the
|
360 | * blue-green sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
361 | */
|
362 | export const schemeBuGn: ReadonlyArray<ReadonlyArray<string>>;
|
363 |
|
364 | /**
|
365 | * Given a number t in the range [0,1], returns the corresponding color from the “BuPu” sequential color scheme represented as an RGB string.
|
366 | *
|
367 | * @param t Number in the range [0, 1].
|
368 | */
|
369 | export function interpolateBuPu(t: number): string;
|
370 |
|
371 | /**
|
372 | * An array of arrays of hexadecimal color strings from the “BuPu” sequential color scheme. The kth element of this array contains
|
373 | * the color scheme of size k; for example, d3.schemeBuPu[9] contains an array of nine strings representing the nine colors of the
|
374 | * blue-purple sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
375 | */
|
376 | export const schemeBuPu: ReadonlyArray<ReadonlyArray<string>>;
|
377 |
|
378 | /**
|
379 | * Given a number t in the range [0,1], returns the corresponding color from the “GnBu” sequential color scheme represented as an RGB string.
|
380 | *
|
381 | * @param t Number in the range [0, 1].
|
382 | */
|
383 | export function interpolateGnBu(t: number): string;
|
384 |
|
385 | /**
|
386 | * An array of arrays of hexadecimal color strings from the “GnBu” sequential color scheme. The kth element of this array contains
|
387 | * the color scheme of size k; for example, d3.schemeGnBu[9] contains an array of nine strings representing the nine colors of the
|
388 | * green-blue sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
389 | */
|
390 | export const schemeGnBu: ReadonlyArray<ReadonlyArray<string>>;
|
391 |
|
392 | /**
|
393 | * Given a number t in the range [0,1], returns the corresponding color from the “OrRd” sequential color scheme represented as an RGB string.
|
394 | *
|
395 | * @param t Number in the range [0, 1].
|
396 | */
|
397 | export function interpolateOrRd(t: number): string;
|
398 |
|
399 | /**
|
400 | * An array of arrays of hexadecimal color strings from the “OrRd” sequential color scheme. The kth element of this array contains
|
401 | * the color scheme of size k; for example, d3.schemeOrRd[9] contains an array of nine strings representing the nine colors of the
|
402 | * orange-red sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
403 | */
|
404 | export const schemeOrRd: ReadonlyArray<ReadonlyArray<string>>;
|
405 |
|
406 | /**
|
407 | * Given a number t in the range [0,1], returns the corresponding color from the “PuBuGn” sequential color scheme represented as an RGB string.
|
408 | *
|
409 | * @param t Number in the range [0, 1].
|
410 | */
|
411 | export function interpolatePuBuGn(t: number): string;
|
412 |
|
413 | /**
|
414 | * An array of arrays of hexadecimal color strings from the “PuBuGn” sequential color scheme. The kth element of this array contains
|
415 | * the color scheme of size k; for example, d3.schemePuBuGn[9] contains an array of nine strings representing the nine colors of the
|
416 | * purple-blue-green sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
417 | */
|
418 | export const schemePuBuGn: ReadonlyArray<ReadonlyArray<string>>;
|
419 |
|
420 | /**
|
421 | * Given a number t in the range [0,1], returns the corresponding color from the “PuBu” sequential color scheme represented as an RGB string.
|
422 | *
|
423 | * @param t Number in the range [0, 1].
|
424 | */
|
425 | export function interpolatePuBu(t: number): string;
|
426 |
|
427 | /**
|
428 | * An array of arrays of hexadecimal color strings from the “PuBu” sequential color scheme. The kth element of this array contains
|
429 | * the color scheme of size k; for example, d3.schemePuBu[9] contains an array of nine strings representing the nine colors of the
|
430 | * purple-blue sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
431 | */
|
432 | export const schemePuBu: ReadonlyArray<ReadonlyArray<string>>;
|
433 |
|
434 | /**
|
435 | * Given a number t in the range [0,1], returns the corresponding color from the “PuRd” sequential color scheme represented as an RGB string.
|
436 | *
|
437 | * @param t Number in the range [0, 1].
|
438 | */
|
439 | export function interpolatePuRd(t: number): string;
|
440 |
|
441 | /**
|
442 | * An array of arrays of hexadecimal color strings from the “PuRd” sequential color scheme. The kth element of this array contains
|
443 | * the color scheme of size k; for example, d3.schemePuRd[9] contains an array of nine strings representing the nine colors of the
|
444 | * purple-red sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
445 | */
|
446 | export const schemePuRd: ReadonlyArray<ReadonlyArray<string>>;
|
447 |
|
448 | /**
|
449 | * Given a number t in the range [0,1], returns the corresponding color from the “RdPu” sequential color scheme represented as an RGB string.
|
450 | *
|
451 | * @param t Number in the range [0, 1].
|
452 | */
|
453 | export function interpolateRdPu(t: number): string;
|
454 |
|
455 | /**
|
456 | * An array of arrays of hexadecimal color strings from the “RdPu” sequential color scheme. The kth element of this array contains
|
457 | * the color scheme of size k; for example, d3.schemeRdPu[9] contains an array of nine strings representing the nine colors of the
|
458 | * red-purple sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
459 | */
|
460 | export const schemeRdPu: ReadonlyArray<ReadonlyArray<string>>;
|
461 |
|
462 | /**
|
463 | * Given a number t in the range [0,1], returns the corresponding color from the “YlGnBu” sequential color scheme represented as an RGB string.
|
464 | *
|
465 | * @param t Number in the range [0, 1].
|
466 | */
|
467 | export function interpolateYlGnBu(t: number): string;
|
468 |
|
469 | /**
|
470 | * An array of arrays of hexadecimal color strings from the “YlGnBu” sequential color scheme. The kth element of this array contains
|
471 | * the color scheme of size k; for example, d3.schemeYlGnBu[9] contains an array of nine strings representing the nine colors of the
|
472 | * yellow-green-blue sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
473 | */
|
474 | export const schemeYlGnBu: ReadonlyArray<ReadonlyArray<string>>;
|
475 |
|
476 | /**
|
477 | * Given a number t in the range [0,1], returns the corresponding color from the “YlGn” sequential color scheme represented as an RGB string.
|
478 | *
|
479 | * @param t Number in the range [0, 1].
|
480 | */
|
481 | export function interpolateYlGn(t: number): string;
|
482 |
|
483 | /**
|
484 | * An array of arrays of hexadecimal color strings from the “YlGn” sequential color scheme. The kth element of this array contains
|
485 | * the color scheme of size k; for example, d3.schemeYlGn[9] contains an array of nine strings representing the nine colors of the
|
486 | * yellow-green sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
487 | */
|
488 | export const schemeYlGn: ReadonlyArray<ReadonlyArray<string>>;
|
489 |
|
490 | /**
|
491 | * Given a number t in the range [0,1], returns the corresponding color from the “YlOrBr” sequential color scheme represented as an RGB string.
|
492 | *
|
493 | * @param t Number in the range [0, 1].
|
494 | */
|
495 | export function interpolateYlOrBr(t: number): string;
|
496 |
|
497 | /**
|
498 | * An array of arrays of hexadecimal color strings from the “YlOrBr” sequential color scheme. The kth element of this array contains
|
499 | * the color scheme of size k; for example, d3.schemeYlOrBr[9] contains an array of nine strings representing the nine colors of the
|
500 | * yellow-orange-brown sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
501 | */
|
502 | export const schemeYlOrBr: ReadonlyArray<ReadonlyArray<string>>;
|
503 |
|
504 | /**
|
505 | * Given a number t in the range [0,1], returns the corresponding color from the “YlOrRd” sequential color scheme represented as an RGB string.
|
506 | *
|
507 | * @param t Number in the range [0, 1].
|
508 | */
|
509 | export function interpolateYlOrRd(t: number): string;
|
510 |
|
511 | /**
|
512 | * An array of arrays of hexadecimal color strings from the “YlOrRd” sequential color scheme. The kth element of this array contains
|
513 | * the color scheme of size k; for example, d3.schemeYlOrRd[9] contains an array of nine strings representing the nine colors of the
|
514 | * yellow-orange-red sequential color scheme. Sequential, multi-hue color schemes support a size k ranging from 3 to 9.
|
515 | */
|
516 | export const schemeYlOrRd: ReadonlyArray<ReadonlyArray<string>>;
|